public member function
<memory>

std::shared_ptr::shared_ptr

default (1)
constexpr shared_ptr() noexcept;
from null pointer (2)
constexpr shared_ptr(nullptr_t) : shared_ptr() {}
from pointer (3)
template <class U> explicit shared_ptr (U* p);
with deleter (4)
template <class U, class D> shared_ptr (U* p, D del);
template <class D> shared_ptr (nullptr_t p, D del);
with allocator (5)
template <class U, class D, class Alloc> shared_ptr (U* p, D del, Alloc alloc);
template <class D, class Alloc> shared_ptr (nullptr_t p, D del, Alloc alloc);
copy (6)
shared_ptr (const shared_ptr& x) noexcept;
template <class U> shared_ptr (const shared_ptr<U>& x) noexcept;
copy from weak (7)
template <class U> explicit shared_ptr (const weak_ptr<U>& x);
move (8)
shared_ptr (shared_ptr&& x) noexcept;
template <class U> shared_ptr (shared_ptr<U>&& x) noexcept;
move from managed (9)
template <class U> shared_ptr (auto_ptr<U>&& x);
template <class U, class D> shared_ptr (unique_ptr<U,D>&& x);
aliasing (10)
template <class U> shared_ptr (const shared_ptr<U>& x, element_type* p) noexcept;
Construct shared_ptr
Constructs a shared_ptr object, depending on the signature used:

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 (2), 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 (3), 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 (5), 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 (5), 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;
}


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

See also