# std::make_shared, std::make_shared_default_init

From cppreference.com
< cpp‎ | memory‎ | shared ptr

Defined in header `<memory>` |  |
template< class T, class... Args > shared_ptr<T> make_shared( Args&&... args ); | (1) | (since C++11) (T is not array)
template<class T> shared_ptr<T> make_shared( std::size_t N ); | (2) | (since C++20) (T is U[])
template<class T> shared_ptr<T> make_shared(); | (3) | (since C++20) (T is U[N])
template<class T> shared_ptr<T> make_shared( std::size_t N, const std::remove_extent_t<T>& u ); | (4) | (since C++20) (T is U[])
template<class T> shared_ptr<T> make_shared( const std::remove_extent_t<T>& u ); | (5) | (since C++20) (T is U[N])
template<class T> shared_ptr<T> make_shared_default_init(); | (6) | (since C++20) (T is not U[])
template<class T> shared_ptr<T> make_shared_default_init( std::size_t N ); | (7) | (since C++20) (T is U[])

1) 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`. This overload only participates in overload resolution if T is not an array type
2,3) Same as (1), but the object constructed is a possibly-multidimensional array whose non-array elements of type `std::remove_all_extents_t<T>` are value-initialized as if by placement-new expression ::new(pv) std::remove_all_extents_t<T>(). The overload (2) creates an array of size `N` along the first dimension. The array elements are initialized in ascending order of their addresses, and when their lifetime ends are destroyed in the reverse order of their original construction.
4,5) Same as (2,3), but every element is initialized from the default value `u`. If `U` is not an array type, then this is performed as if by the same placement-new expression as in (1); otherwise, this is performed as if by initializing every non-array element of the (possibly multidimensional) array with the corresponding element from `u` with the same placement-new expression as in (1). The overload (4) creates an array of size `N` along the first dimension. The array elements are initialized in ascending order of their addresses, and when their lifetime ends are destroyed in the reverse order of their original construction.
6) Same as (1) if `T` is not an array type and (3) if `T` is `U[N]`, except that the created object is default-initialized.
7) Same as (2), except that the individual array elements are default-initialized.

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

args | - | list of arguments with which an instance of `T` will be constructed.
N | - | array size to use
u | - | the initial value to initialize every element of the array

### 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...)).

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++20)

code such as f(std::shared_ptr<int>(new int(42)), g()) can cause a memory leak if `g` gets called after `new int(42)` and throws an exception, while f(std::make_shared<int>(42), g()) is safe, since two function calls are never interleaved. | (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 (since C++17) 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.

### Example

Run this code

    #include <iostream>
    #include <memory>
    #include <type_traits>

    struct C
    {
      C(int i) : i(i) {} //< constructor needed (until C++20)
      int i;
    };

    int main()
    {
        auto sp = std::make_shared<C>(12);

        static_assert(std::is_same_v<decltype(sp), std::shared_ptr<C>>);

        std::cout << sp->i << '\n';
    }

Output:

    12

### See also

(constructor) | constructs new `shared_ptr` (public member function)
allocate_shared allocate_shared_default_init (C++20) | creates a shared pointer that manages a new object allocated using an allocator (function template)
make_unique make_unique_default_init (C++14)(C++20) | creates a unique pointer that manages a new object (function template)
operator new operator new[] | allocation functions (function)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/shared_ptr/make_shared&oldid=107704"