Namespaces
Variants
Views
Actions

std::unique_ptr

From cppreference.com
< cpp‎ | memory
Revision as of 11:12, 16 May 2013 by P12 (Talk | contribs)

 
 
 
 
 

Template:ddcl list begin <tr class="t-dsc-header">

<td>
Defined in header <memory>
</td>

<td></td> <td></td> <tr class="t-dcl-sep"><td></td><td></td><td></td></tr>

<tr class="t-dcl ">

<td >
template<

    class T,
    class Deleter = std::default_delete<T>

> class unique_ptr;
</td>

<td > (1) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl-sep"><td></td><td></td><td></td></tr>

<tr class="t-dcl ">

<td >
template <

    class T,
    class Deleter

> class unique_ptr<T[],Deleter>;
</td>

<td > (2) </td> <td > (since C++11) </td> </tr> Template:ddcl list end

std::unique_ptr is a smart pointer that retains sole ownership of an object through a pointer and destroys that object when the unique_ptr goes out of scope. No two unique_ptr instances can manage the same object.

The object is destroyed and its memory deallocated when either of the following happens:

  • unique_ptr managing the object is destroyed
  • unique_ptr managing the object is assigned another pointer via Template:rlf or Template:rlf.

The object is destroyed using a potentially user-supplied deleter by calling Deleter(ptr). The deleter calls the destructor of the object and dispenses the memory.

A unique_ptr may also own no objects, in which case it is called empty.

There are two versions of std::unique_ptr:

1) Manages the lifetime of a single object (e.g. allocated with new)
2) Manages the lifetime of a dynamically-allocated array of objects (e.g. allocated with new[])

The class satisfies the requirements of MoveConstructible and MoveAssignable, but not the requirements of either CopyConstructible or CopyAssignable.

Contents

Notes

Only non-const unique_ptr can transfer the ownership of the managed object to another unique_ptr. The lifetime of an object managed by const std::unique_ptr is limited to the scope in which the pointer was created.

Typical uses of std::unique_ptr include:

  • providing exception safety to classes and functions that handle objects with dynamic lifetime, by guaranteeing deletion on both normal exit and exit through exception
  • passing ownership of uniquely-owned objects with dynamic lifetime into functions
  • acquiring ownership of uniquely-owned objects with dynamic lifetime from functions
  • as the element type in move-aware containers, such as std::vector, which hold pointers to dynamically-allocated objects (e.g. if polymorphic behavior is desired)

Member types

Member type Definition
pointer std::remove_reference<D>::type::pointer if that type exists, otherwise T*
element_type T, the type of the object managed by this unique_ptr
deleter_type Deleter, the function object or lvalue reference to function or to function object, to be called from the destructor

Member functions

Template:cpp/memory/unique ptr/dcl list constructorTemplate:cpp/memory/unique ptr/dcl list destructorTemplate:cpp/memory/unique ptr/dcl list operator=Template:cpp/memory/unique ptr/dcl list releaseTemplate:cpp/memory/unique ptr/dcl list resetTemplate:cpp/memory/unique ptr/dcl list swapTemplate:cpp/memory/unique ptr/dcl list getTemplate:cpp/memory/unique ptr/dcl list get deleterTemplate:cpp/memory/unique ptr/dcl list operator boolTemplate:cpp/memory/unique ptr/dcl list operator*Template:cpp/memory/unique ptr/dcl list operator at
Modifiers
Observers
Single-object version, unique_ptr<T>
Array version, unique_ptr<T[]>

Non-member functions

Template:cpp/memory/unique ptr/dcl list make uniqueTemplate:cpp/memory/unique ptr/dcl list operator cmpTemplate:cpp/memory/unique ptr/dcl list swap2

Helper classes

Template:cpp/memory/unique ptr/dcl list hash

Example

#include <iostream>
#include <memory>
 
struct Foo {
    Foo() { std::cout << "Foo::Foo\n"; }
    ~Foo() { std::cout << "Foo::~Foo\n"; }
    void bar() { std::cout << "Foo::bar\n"; }
};
 
void f(const Foo &)
{
    std::cout << "f(const Foo&)\n";
}
 
int main()
{
    std::unique_ptr<Foo> p1(new Foo);  // p1 owns Foo
    if (p1) p1->bar();
 
    {
        std::unique_ptr<Foo> p2(std::move(p1));  // now p2 owns Foo
        f(*p2);
 
        p1 = std::move(p2);  // ownership returns to p1
        std::cout << "destroying p2...\n";
    }
 
    if (p1) p1->bar();
 
    // Foo instance is destroyed when p1 goes out of scope
}

Output:

Foo::Foo
Foo::bar
f(const Foo&)
destroying p2...
Foo::bar
Foo::~Foo