##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::make_shared

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

Defined in header `<memory>` |  |
template< class T, class... Args > shared_ptr<T> make_shared( Args&&... args ); |  |

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`.

### [edit] Parameters

args | - | list of arguments with which an instance of `T` will be constructed.

### [edit] Return value

std::shared_ptr of an instance of type `T`.

### [edit] Exceptions

May throw std::bad_alloc or any exception thrown by the constructor of `T`. If an exception is thrown, this function has no effect.

### [edit] Notes

This function is typically used to replace the construction std::shared_ptr<T>(new T(args...)) of a shared pointer from the raw pointer returned by a call to `new`. In contrast to that expression, std::make_shared<T> typically allocates memory for the `T` object and for the std::shared_ptr's control block with a single memory allocation (this is a non-binding requirement in the Standard), where std::shared_ptr<T>(new T(args...)) performs at least two memory allocations.

Moreover, code such as f(std::shared_ptr<int>(new int(42)), g()) can cause a memory leak if `g` throws an exception because `g()` may be called after `new int(42)` and before the constructor of `shared_ptr<int>`. This doesn't occur in f(std::make_shared<int>(42), g()), since two function calls are never interleaved.

### [edit] Example

Run this code

    #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

### [edit] See also

(constructor) | constructs new `shared_ptr` (public member function) [edit]
allocate_shared | creates a shared pointer that manages a new object allocated using an allocator (function template) [edit]

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