c++11 & 14: unique_ptr shared_ptr std::make_unique(c++14)

参考网站：

   http://www.cplusplus.com/reference/utility/pair/

Both of these classes are smart pointers, which means that they automatically (in most cases) will deallocate the object that they point at when that object can no longer be referenced. The difference between the two is how many different pointers of each type can refer to a resource.

When using unique_ptr, there can be at most one unique_ptr pointing at any one resource. When that unique_ptr is destroyed, the resource is automatically reclaimed. Because there can only be one unique_ptr to any resource, any attempt to make a copy of a unique_ptr will cause a compile-time error. For example, this code is illegal:

unique_ptr<T> myPtr(new T);       // Okayunique_ptr<T> myOtherPtr = myPtr; // Error: Can't copy unique_ptr

However, unique_ptr can be moved using the new move semantics:

unique_ptr<T> myPtr(new T);                  // Okayunique_ptr<T> myOtherPtr = std::move(myPtr); // Okay, resource now stored in myOtherPtr

Similarly, you can do something like this:

unique_ptr<T> MyFunction() {    unique_ptr<T> myPtr(/* ... */);    /* ... */    return myPtr;}

This idiom means "I'm returning a managed resource to you. If you don't explicitly capture the return value, then the resource will be cleaned up. If you do, then you now have exclusive ownership of that resource." In this way, you can think of unique_ptr as a safer, better replacement for auto_ptr.

shared_ptr, on the other hand, allows for multiple pointers to point at a given resource. When the very last shared_ptr to a resource is destroyed, the resource will be deallocated. For example, this code is perfectly legal:

shared_ptr<T> myPtr(new T);       // Okayshared_ptr<T> myOtherPtr = myPtr; // Sure!  Now have two pointers to the resource.

Internally, shared_ptr uses reference counting to track how many pointers refer to a resource, so you need to be careful not to introduce any reference cycles.

In short:

1. Use unique_ptr when you want a single pointer to an object that will be reclaimed when that single pointer is destroyed.
2. Use shared_ptr when you want multiple pointers to the same resource.

Hope this helps!

std::make_unique

 

C++

 

Utilities library

 

Dynamic memory management

 

std::unique_ptr

 

Defined in header <memory>

  template< class T, class... Args >
unique_ptr<T> make_unique( Args&&... args );(1)(since C++14)
(only for non-array types)template< class T >
unique_ptr<T> make_unique( std::size_t size );(2)(since C++14)
(only for array types with unknown bound)template< class T, class... Args >
/* unspecified */ make_unique( Args&&... args ) = delete;(3)(since C++14)
(only for array types with known bound)   

Constructs an object of type T and wraps it in a std::unique_ptr.

1) Constructs a non-array type T. The arguments args are passed to the constructor of T. The function does not participate in the overload resolution if T is an array type. The function is equivalent to:

unique_ptr<T>(new T(std::forward<Args>(args)...))

2) Constructs an array of unknown bound T. The function does not participate in the overload resolution unless Tis an array of unknown bound. The function is equivalent to:

unique_ptr<T>(new typename std::remove_extent<T>::type[size]())

3) Construction of arrays of known bound is disallowed.

Parameters

args-list of arguments with which an instance of T will be constructed.size-the size of the array to construct

Return value

std::unique_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, this function has no effect.

Example

Run this code

#include <iostream>#include <memory> struct Vec3{    int x, y, z;    Vec3() : x(0), y(0), z(0) { }    Vec3(int x, int y, int z) :x(x), y(y), z(z) { }    friend std::ostream& operator<<(std::ostream& os, Vec3& v) {        return os << '{' << "x:" << v.x << " y:" << v.y << " z:" << v.z  << '}';    }}; int main(){    // Use the default constructor.    std::unique_ptr<Vec3> v1 = std::make_unique<Vec3>();    // Use the constructor that matches these arguments    std::unique_ptr<Vec3> v2 = std::make_unique<Vec3>(0, 1, 2);    // Create a unique_ptr to an array of 5 elements    std::unique_ptr<Vec3[]> v3 = std::make_unique<Vec3[]>(5);     std::cout << "make_unique<Vec3>():      " << *v1 << '\n'              << "make_unique<Vec3>(0,1,2): " << *v2 << '\n'              << "make_unique<Vec3[]>(5):   " << '\n';    for (int i = 0; i < 5; i++) {        std::cout << "     " << v3[i] << '\n';    }}

Output:

make_unique<Vec3>():      {x:0 y:0 z:0}make_unique<Vec3>(0,1,2): {x:0 y:1 z:2}make_unique<Vec3[]>(5):        {x:0 y:0 z:0}     {x:0 y:0 z:0}     {x:0 y:0 z:0}     {x:0 y:0 z:0}     {x:0 y:0 z:0}

See also

(constructor)

constructs a new unique_ptr 
(public member function)