std::unique_ptr::reset

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Dynamic memory management

Smart pointers
unique_ptr (C++11)
shared_ptr (C++11)
weak_ptr (C++11)
auto_ptr (deprecated)
owner_less (C++11)
enable_shared_from_this (C++11)
bad_weak_ptr (C++11)
default_delete (C++11)
Allocators
allocator
allocator_traits (C++11)
allocator_arg_t (C++11)
allocator_arg (C++11)
uses_allocator (C++11)
scoped_allocator_adaptor (C++11)
Uninitialized storage
uninitialized_copy
uninitialized_copy_n (C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
Garbage collection support
declare_reachable (C++11)
undeclare_reachable (C++11)
declare_no_pointers (C++11)
undeclare_no_pointers (C++11)
pointer_safety (C++11)
get_pointer_safety (C++11)
Miscellaneous
pointer_traits (C++11)
addressof (C++11)
align (C++11)
C Library
malloc calloc	realloc free
Low level memory management

 

std::unique_ptr

Member functions

unique_ptr::unique_ptr

unique_ptr::~unique_ptr

unique_ptr::operator=

Modifiers

unique_ptr::release

unique_ptr::reset

unique_ptr::swap

Observers

unique_ptr::get

unique_ptr::get_deleter

unique_ptr::operator bool

unique_ptr::operator*unique_ptr::operator->

unique_ptr::operator[]

Non-member functions

operator==operator!=operator<operator>operator<=operator>operator>=

std::swap

std::hash

 

void reset( pointer ptr = pointer() );	(1)	(since C++11)
template< class U > void reset( U ) = delete;	(2)	(since C++11) (member of specialization unique_ptr<T[]> only)
void reset( std::nullptr_t p );	(3)	(since C++11) (member of specialization unique_ptr<T[]> only)

Replaces the managed object.

1) Given current_ptr, the pointer that was managed by *this, performs the following actions, in this order:

1. Saves a copy of the current pointer old_ptr = current_ptr
2. Overwrites the current pointer with the argument current_ptr = ptr
3. If the old pointer was non-empty, deletes the previously managed object if(old_ptr != nullptr) get_deleter()(old_ptr).

2) In the specialization for dynamic arrays, std::unique_ptr<T[]>, this template member is provided to prevent using reset() with a pointer to derived (which would result in undefined behavior with arrays).

3) In the specialization for dynamic arrays, std::unique_ptr<T[]>, the third overload is necessary to allow reset to nullptr (which would otherwise be prohibited by the template overload). Equivalent to reset(pointer())

Parameters

ptr

-

pointer to a new object to manage

Return value

(none)

Exceptions

noexcept specification:  

noexcept

  

Notes

To replace the managed object while supplying a new deleter as well, move assignment operator may be used.

A test for self-reset, i.e. whether ptr points to an object already managed by *this, is not performed, except where provided as a compiler extension or as a debugging assert. Note that code such as p.reset(p.release()) does not involve self-reset, only code like p.reset(p.get()) does.

Visual Studio's implementation of reset is currently (in VC10 and VC11) broken and non-conforming to the C++11 standard. It deletes the managed object before resetting the pointer to the owned object.

Example

Run this code

#include <iostream>
#include <memory>
 
struct Foo {
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};
 
struct D {
    void operator() (Foo* p) {
        std::cout << "Calling delete for Foo object... \n";
        delete p;
    }
};
 
int main()
{
    std::cout << "Creating new Foo...\n";
    std::unique_ptr<Foo, D> up(new Foo(), D());  // up owns the Foo pointer (deleter D)
 
    std::cout << "Replace owned Foo with a new Foo...\n";
    up.reset(new Foo());  // calls deleter for the old one
 
    std::cout << "Release and delete the owned Foo...\n";
    up.reset(nullptr);      
}

Output:

Creating new Foo...
Foo...
Replace owned Foo with a new Foo...
Foo...
Calling delete for Foo object...
~Foo...
Release and delete the owned Foo...
Calling delete for Foo object...
~Foo...

See also

release

returns a pointer to the managed object and releases the ownership (public member function)