Defined in header <memory> | ||
---|---|---|
template< class T, class... Args > shared_ptr<T> make_shared( Args&&... args ); | (since C++11) |
Constructs an object of type T
and wraps it in a std::shared_ptr
using args
as the parameter list for the constructor of T
. The object is constructed as if by the expression ::new (pv) T(std::forward<Args>(args)...)
, where pv
is an internal void*
pointer to storage suitable to hold an object of type T
. The storage is typically larger than sizeof(T)
in order to use one allocation for both the control block of the shared pointer and the T
object.
The std::shared_ptr
constructor called by this function enables shared_from_this
with a pointer to the newly constructed object of type T
.
args | - | list of arguments with which an instance of T will be constructed. |
std::shared_ptr
of an instance of type T
.
May throw std::bad_alloc
or any exception thrown by the constructor of T
. If an exception is thrown, this function has no effect.
This function may be used as an alternative to std::shared_ptr<T>(new T(args...))
. The trade-offs are:
std::shared_ptr<T>(new T(args...))
performs at least two allocations (one for the object T
and one for the control block of the shared pointer), while std::make_shared<T>
typically performs only one allocation (the standard recommends, but does not require this, all known implementations do this) std::weak_ptr
references the control block created by std::make_shared
after the lifetime of all shared owners ended, the memory occupied by T
persists until all weak owners get destroyed as well, which may be undesirable if sizeof(T)
is large. std::shared_ptr<T>(new T(args...))
may call a non-public constructor of T
if executed in context where it is accessible, while std::make_shared
requires public access to the selected constructor. std::shared_ptr
constructors, std::make_shared
does not allow a custom deleter. std::shared_ptr
supports array types (as of C++17), but std::make_shared
does not. This functionality is supported by boost::make_shared
| (until C++17) |
A constructor enables shared_from_this
with a pointer ptr
of type U*
means that it determines if U
has an unambiguous and accessible base class that is a specialization of std::enable_shared_from_this
, and if so, the constructor evaluates the statement:
if (ptr != nullptr && ptr->weak_this.expired()) ptr->weak_this = std::shared_ptr<std::remove_cv_t<U>>(*this, const_cast<std::remove_cv_t<U>*>(ptr));
Where weak_this
is the hidden mutable std::weak_ptr
member of std::shared_from_this
. The assignment to the weak_this member is not atomic and conflicts with any potentially concurrent access to the same object. This ensures that future calls to shared_from_this()
would share ownership with the shared_ptr
created by this raw pointer constructor.
The test ptr->weak_this.expired()
in the exposition code above makes sure that weak_this is not reassigned if it already indicates an owner. This test is required as of C++17.
#include <iostream> #include <memory> void foo(const std::shared_ptr<int>& i) { (*i)++; } int main() { auto sp = std::make_shared<int>(12); foo(sp); std::cout << *sp << std::endl; }
Output:
13
constructs new shared_ptr (public member function) |
|
creates a shared pointer that manages a new object allocated using an allocator (function template) |
|
(C++14) | creates a unique pointer that manages a new object (function template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared