[#bsl-shared_ptr-0a-reset-0e]
= xref:bsl.adoc[bsl]::xref:bsl/shared_ptr-0a.adoc[shared_ptr]::reset
:relfileprefix: ../../
:mrdocs:

Modify this shared pointer to manage the modifiable object of the (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr` address, refer to `(ELEMENT_TYPE *)ptr`, and use the specified `deleter` to delete the shared object when all references have been released. If this shared pointer is already managing a (possibly shared) object, then unless an exception is thrown allocating memory to manage `ptr`, release the reference to the shared object, calling the associated deleter to destroy the shared object if this shared pointer is the last reference. If `DELETER` is an object type, then `deleter` is assumed to be a function‐like deleter that may be invoked to destroy the object referred to by a single argument of type `COMPATIBLE_TYPE *` (i.e., `deleter(ptr)` will be called to destroy the shared object). If `DELETER` is a pointer type that is not a function pointer, then `deleter` shall be a pointer to a factory object that exposes a member function that can be invoked as `deleteObject(ptr)` that will be called to destroy the object at the `ptr` address (i.e., `deleter‐>deleteObject(ptr)` will be called to delete the shared object). (See the "Deleters" section in the component‐level documentation.) If `DELETER` is also a pointer to `bslma::Allocator` or to a class derived from `bslma::Allocator`, then that allocator will also be used to allocate and destroy the internal representation of this shared pointer when all references have been released; otherwise, the currently installed default allocator is used to allocate and destroy the internal representation of this shared pointer when all references have been released. If an exception is thrown allocating the internal representation, then `deleter(ptr)` is called (or `deleter‐>deleteObject(ptr)` for factory‐type deleters) and this shared pointer retains ownership of its original object. If `COMPATIBLE_TYPE*` is not implicitly convertible to `ELEMENT_TYPE*`, then a compiler diagnostic will be emitted indicating the error. Note that, for factory deleters, `deleter` must remain valid until all references to `ptr` have been released. If `ptr` is 0, then an internal representation will still be allocated, and this shared pointer will share ownership of a copy of `deleter`. Further note that this function is logically equivalent to: ` *this = shared_ptr<ELEMENT_TYPE>(ptr, deleter); `

== Synopsis

Declared in `<bslstl_sharedptr.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<
    class COMPATIBLE_TYPE,
    class DELETER>
void
reset(
    COMPATIBLE_TYPE* ptr,
    DELETER deleter)
requires is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value;
----


[.small]#Created with https://www.mrdocs.com[MrDocs]#