Difference between revisions of "cpp/memory/shared ptr/make shared"

Revision as of 15:43, 6 October 2021

In each case, the object (or individual elements if T is an array type)(since C++20) will be destroyed by p->~X(), where p is a pointer to the object and X is its type.

Parameters

Return value

std::shared_ptr of an instance of type T.

Exceptions

May throw std::bad_alloc or any exception thrown by the constructor of T. If an exception is thrown, the functions have no effect. If an exception is thrown during the construction of the array, already-initialized elements are destroyed in reverse order.(since C++20)

Notes

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)
• If any 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.
• Unlike the std::shared_ptr constructors, std::make_shared does not allow a custom deleter.
• std::make_shared uses ::new, so if any special behavior has been set up using a class-specific operator new, it will differ from std::shared_ptr<T>(new T(args...)).

A constructor enables shared_from_this with a pointer ptr of type U* means that it determines if U has an unambiguous and accessible(since C++17) base class that is a specialization of std::enable_shared_from_this, and if so, the constructor evaluates 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)); .

The assignment to the weak_this 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 std::shared_ptr created by this raw pointer constructor.

The test ptr->weak_this .expired() in the code above makes sure that weak_this is not reassigned if it already indicates an owner. This test is required as of C++17.

Example

#include <iostream>
#include <memory>
#include <type_traits>
 
struct C
{
  C(int i) : i(i) {} //< constructor needed (until C++20)
  int i;
};
 
int main()
{
    // using `auto` for the type of `sp1`
    auto sp1 = std::make_shared<C>(12);
    static_assert(std::is_same_v<decltype(sp1), std::shared_ptr<C>>);
    std::cout << sp1->i << '\n';
 
    // being explicit with the type of `sp2`
    std::shared_ptr<C> sp2 = std::make_shared<C>(13);
    static_assert(std::is_same_v<decltype(sp2), std::shared_ptr<C>>);
    std::cout << sp2->i << '\n';
}

12
13

See also