[#BloombergLP-bslma-ManagedPtr_Members]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslma.adoc[bslma]::ManagedPtr_Members
:relfileprefix: ../../
:mrdocs:

This class provides a type‐agnostic container for managed pointer data members. This type exists so that a `ManagedPtr_Ref` (see `bslma_managedptr`) can point to the representation of a `ManagedPtr` even if the `ManagedPtr_Ref` object is instantiated on a different type than the managed pointer type (e.g., in the case of conversions or aliasing). `ManagedPtr_Members` also "erases" the type of each member, so that the same object code can be shared between all instantiations of the `ManagedPtr` class template, reducing template bloat. Note that objects of this type have an "unset" state, where the pointer member has a null value and the deleter member has an unspecified value.

== Synopsis

Declared in `<bslma_managedptr_members.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class ManagedPtr_Members;
----

== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/ManagedPtr_Members/2constructor-00.adoc[`ManagedPtr_Members`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bslma/ManagedPtr_Members/clear.adoc[`clear`] 
| Reset this object to an unset state with no effect on the previously managed object (if any).
| xref:BloombergLP/bslma/ManagedPtr_Members/deleter.adoc[`deleter`] 
| Return a reference providing non‐modifiable access to the deleter used to destroy the currently managed object (if any). The behavior is undefined unless `pointer` is not null.
| xref:BloombergLP/bslma/ManagedPtr_Members/move.adoc[`move`] 
| Reset this object to have the same `pointer` as the specified `other` object, and, if `0 != other‐>pointer()`, the same deleter as `other`, then put `other` into an unset state. This method has no effect on the previously managed object (if any). The behavior is undefined unless `this != other`.
| xref:BloombergLP/bslma/ManagedPtr_Members/moveAssign.adoc[`moveAssign`] 
| Destroy the currently managed object (if any), reset this object to have the same `pointer` as the specified `other` object, and, if `0 != other‐>pointer()`, the same deleter as `other`, then put `other` into an unset state. This method has no effect if `this == other`.
| xref:BloombergLP/bslma/ManagedPtr_Members/pointer.adoc[`pointer`] 
| Return the address providing modifiable access to the currently managed object, or 0 if this object is in an unset state. Note that the returned pointer may be an alias to the managed object.
| xref:BloombergLP/bslma/ManagedPtr_Members/runDeleter.adoc[`runDeleter`] 
| Destroy the currently managed object (if any). Note that calling this method twice on an object that is not in an unset state, without assigning a new pointer to manage between the two calls, results in undefined behavior unless this object's deleter specifically supports such usage.
| xref:BloombergLP/bslma/ManagedPtr_Members/set.adoc[`set`] 
| Reset this object to have the specified `object`, `factory`, and `deleter` with no effect on the previously managed object (if any). The object does not manage a pointer if `0 == object`. The behavior is undefined unless `object` is null if `deleter` is null.
| xref:BloombergLP/bslma/ManagedPtr_Members/setAliasPtr.adoc[`setAliasPtr`] 
| Set `pointer` to have the specified `alias`. If `0 == alias`, then this object will have an unset state with no effect on the previously managed object (if any). The behavior is undefined unless `0 == pointer()` if and only if `0 == alias`.
| xref:BloombergLP/bslma/ManagedPtr_Members/swap.adoc[`swap`] 
| Efficiently exchange the state of this object with the state of the specified `other` object. This method provides the no‐throw exception‐safety guarantee. Note that if either object is in an unset state, then the only guarantee about the unset state that may be exchanged is that the `pointer` value shall be null.
|===



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