std::shared_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::shared_ptr

Member functions

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modifiers

shared_ptr::reset

shared_ptr::swap

Observers

shared_ptr::get

shared_ptr::operator*shared_ptr::operator->

shared_ptr::use_count

shared_ptr::unique

shared_ptr::operator bool

shared_ptr::owner_before

Non-member functions

std::swap

make_shared

allocate_shared

static_pointer_castdynamic_pointer_castconst_pointer_cast

get_deleter

operator==operator|=operator<operator<=operator>operator>=

operator<<

atomic_is_lock_freeatomic_loadatomic_load_explicitatomic_storeatomic_store_explicitatomic_exchangeatomic_exchange_explicitatomic_compare_exchange_weakatomic_compare_exchange_strongatomic_compare_exchange_weak_explicitatomic_compare_exchange_strong_explicit

std::hash

 

void reset();	(1)	(since C++11)
template< class Y > void reset( Y* ptr );	(2)	(since C++11)
template< class Y, class Deleter > void reset( Y* ptr, Deleter d );	(3)	(since C++11)
template< class Y, class Deleter, class Alloc > void reset( Y* ptr, Deleter d, Alloc alloc );	(4)	(since C++11)

Replaces the managed object with an object pointed to by ptr. Optional deleter d can be supplied, which is later used to destroy the new object when no shared_ptr objects own it. By default, delete expression is used as deleter. Proper delete expression corresponding to the supplied type is always selected, this is the reason why the function is implemented as template using a separate parameter Y.

If *this already owns an object and it is the last shared_ptr owning it, the object is destroyed through the owned deleter.

If the object pointed to by ptr is already owned, the function results in undefined behavior.

1) Releases the ownership of the managed object, if any. After the call, *this manages no object. Equivalent to shared_ptr().swap(*this);

2-4) Replaces the managed object with an object pointed to by ptr. Y must be a complete type and implicitly convertible to T. Additionally:

2) Uses the delete expression as the deleter. A valid delete expression must be available, i.e. delete ptr must be well formed, have well-defined behavior and not throw any exceptions. Effectively calls shared_ptr<T>(ptr).swap(*this);.

3) Uses the specified deleter d as the deleter. Deleter must be callable for the type T, i.e. d(ptr) must be well formed, have well-defined behavior and not throw any exceptions. Deleter must be CopyConstructible. Effectively calls shared_ptr<T>(ptr, d).swap(*this);.

4) Same as (3), but additionally uses a copy of alloc for allocation of data for internal use. Alloc must be a Allocator. The copy constructor and destructor must not throw exceptions. Effectively calls shared_ptr<T>(ptr, d, alloc).swap(*this);.

Parameters

ptr	-	pointer to an object to acquire ownership of
d	-	deleter to store for deletion of the object
alloc	-	allocator to use for internal allocations

Return value

(none)

Exceptions

1)

noexcept specification:  

noexcept

  

2-4) As specified by the relevant constructor .

Example

Run this code

#include <memory>
#include <iostream>
 
struct Foo {
    Foo(int n = 0) noexcept : bar(n) {
        std::cout << "Foo: constructor, bar = " << bar << '\n';
    }
    ~Foo() {
         std::cout << "Foo: destructor, bar = " << bar << '\n';
    }
    int getBar() const noexcept { return bar; }
private:
    int bar;
};
 
int main()
{
    std::shared_ptr<Foo> sptr = std::make_shared<Foo>(1);
    std::cout << "The first Foo's bar is " << sptr->getBar() << "\n";
 
    // reset the shared_ptr, hand it a fresh instance of Foo
    // (the old instance will be destroyed ater this call)
    sptr.reset(new Foo);
    std::cout << "The second Foo's bar is " << sptr->getBar() << "\n";
}

Output:

Foo: constructor, bar = 1
The first Foo's bar is 1
Foo: constructor, bar = 0
Foo: destructor, bar = 1
The second Foo's bar is 0
Foo: destructor, bar = 0

See also

(constructor)

constructs new shared_ptr (public member function)