std::shared_ptr::shared_ptr

default constructor (1), and (2)

The object is empty (owns no pointer, use count of zero).

construct from pointer (3)

The object owns p, setting the use count to 1.

construct from pointer + deleter (4)

Same as (3), but the object also takes ownership of deleter del (and uses it if at some point needs to delete p).

construct from pointer + deleter + allocator (5)

Same as (4), but any memory needed for internal use is allocated using alloc (of which the object keeps a copy, but does not take ownership).

copy constructors (6)

If x is not empty, the object shares ownership of x's assets and increases the use count.
If x is empty, an empty object is constructed (as if default-constructed).

copy from weak_ptr (7)

Same as above (6), except that if x has expired, a bad_weak_ptr exception is thrown.

move constructors (8)

The object acquires the content managed by x including its owned pointer. x becomes an empty object (as if default-constructed).

move from other types of managed pointers (9)

The object acquires the content managed by x and sets the use count to 1. The ceding object becomes empty, automatically losing ownership of the pointer.

aliasing constructor (10)

Same as (6), except that the stored pointer is p.
The object does not own p, and will not manage its storage. Instead, it co-owns x's managed object and counts as one additional use of x. It will also delete x's pointer on release (and not p).
It can be used to point to members of objects that are already managed.

Parameters

p

Pointer whose ownership is taken over by the object.
This pointer value shall not be already managed by any other managed pointer (i.e., this value shall not come from calling member get on a managed pointer).
U* shall be implicitly convertible to T* (where T is shared_ptr's template parameter).

del

Deleter object to be used to release the owned object.
This shall be a callable object taking a pointer to T as argument for its functional call (where T is shared_ptr's template parameter).

alloc

Allocator object used to allocate/deallocate internal storage.

x

An object of a managed pointer type.
U* shall be implicitly convertible to T* (where T is shared_ptr's template parameter).

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// shared_ptr constructor example
#include <iostream>
#include <memory>

struct C {int* data;};

int main () {
  std::shared_ptr<int> p1;
  std::shared_ptr<int> p2 (nullptr);
  std::shared_ptr<int> p3 (new int);
  std::shared_ptr<int> p4 (new int, std::default_delete<int>());
  std::shared_ptr<int> p5 (new int, [](int* p){delete p;}, std::allocator<int>());
  std::shared_ptr<int> p6 (p5);
  std::shared_ptr<int> p7 (std::move(p6));
  std::shared_ptr<int> p8 (std::unique_ptr<int>(new int));
  std::shared_ptr<C> obj (new C);
  std::shared_ptr<int> p9 (obj, obj->data);

  std::cout << "use_count:\n";
  std::cout << "p1: " << p1.use_count() << '\n';
  std::cout << "p2: " << p2.use_count() << '\n';
  std::cout << "p3: " << p3.use_count() << '\n';
  std::cout << "p4: " << p4.use_count() << '\n';
  std::cout << "p5: " << p5.use_count() << '\n';
  std::cout << "p6: " << p6.use_count() << '\n';
  std::cout << "p7: " << p7.use_count() << '\n';
  std::cout << "p8: " << p8.use_count() << '\n';
  std::cout << "p9: " << p9.use_count() << '\n';
  return 0;
}

use_count:
p1: 0
p2: 0
p3: 1
p4: 1
p5: 2
p6: 0
p7: 2
p8: 1
p9: 2

See also

shared_ptr::operator=

shared_ptr assignment (public member function )

shared_ptr::reset

Reset pointer (public member function )

shared_ptr::~shared_ptr

Destroy shared_ptr (public member function )