BloombergLP::bslma::ManagedPtr

This class is a "smart pointer" that refers to a target object accessed via a pointer to the specified parameter type, TARGET_TYPE, and that supports sole ownership of a managed object that is potentially of a different type, and may be an entirely different object from the target object. A managed pointer ensures that the object it manages is destroyed when the managed pointer is destroyed (or re-assigned), using the "deleter" supplied along with the managed object. The target object referenced by a managed pointer may be accessed using either the -> operator, or the dereference operator (operator *). The specified TARGET_TYPE may be const-qualified, but may not be volatile-qualified, nor may it be a reference type.

Synopsis

Declared in <bslma_managedptr.h>

template<class TARGET_TYPE>
class ManagedPtr;

Description

A managed pointer may be empty, in which case it neither refers to a target object nor owns a managed object. An empty managed pointer is the equivalent of a null pointer: Such a managed pointer is not de-referenceable, and tests as false in boolean expressions.

A managed pointer for which the managed object is not the same object as the target is said to alias the managed object (see the section "Aliasing" in the component-level documentation).

Type Aliases

Name	Description
`DeleterFunc`	Alias for a function-pointer type for functions used to destroy the object managed by a `ManagedPtr` object.
`element_type`	Alias to the `TARGET_TYPE` template parameter.

Member Functions

Name	Description
`ManagedPtr` [constructor]	Constructors
`~ManagedPtr` [destructor]	Destroy this managed pointer object. Destroy the object managed by this managed pointer by invoking the user-supplied deleter, unless this managed pointer is empty, in which case the deleter will not be called.
`operator=`	Assignment operators
`clear`	Destroy the current managed object (if any) and reset this managed pointer to empty.
`deleter`	Return a reference to the non-modifiable deleter information associated with this managed pointer. The behavior is undefined if this managed pointer is empty.
`get`	Return the address of the target object, or 0 if this managed pointer is empty.
`load`	`load` overloads
`loadAlias`	If the specified `alias` manages the same object as this managed pointer, set the target object of this managed pointer to be that referenced by the specified `ptr`; otherwise, destroy the currently managed object (if any), and if `alias` is empty, reset this managed pointer to empty; otherwise, transfer ownership (and the deleter) of the object managed by `alias`, and set the target object of this managed pointer to be that referenced by `ptr`. The behavior is undefined if `0 == ptr` and `alias` is not empty, or if `0 != ptr` and `alias` is empty, or if `ptr` is already managed by a managed pointer other than `alias`. Note that this establishes a managed pointer where `ptr` aliases `alias`. The managed object for `alias` will ultimately be destroyed, and the destructor for `ptr` is not called directly.
`operator*`	Return a reference to the target object. The behavior is undefined if this managed pointer is empty, or if `TARGET_TYPE` is `void` or `const void`.
`operator->`	Return the address of the target object, or 0 if this managed pointer is empty.
`ptr`	Return the address of the target object, or 0 if this managed pointer is empty.
`release`	`release` overloads
`reset`	Destroy the current managed object (if any) and reset this managed pointer to empty.
`swap`	Exchange the value and ownership of this managed pointer with the specified `other` managed pointer.
`operator BoolType`	Return a value of "unspecified bool" type that evaluates to `false` if this managed pointer is empty, and `true` otherwise. Note that this conversion operator allows a managed pointer to be used within a conditional context, such as within an `if` or `while` statement, but does not allow managed pointers to be compared (e.g., via `<` or `>`). Also note that a superior solution is available in C++11 using the `explicit operator bool()` syntax, that removes the need for a special boolean-like type and private equality-comparison operators.
`operator ManagedPtr_Ref<REFERENCED_TYPE>`	Return a managed pointer reference, referring to this object. Note that this conversion operator is used implicitly to allow the construction of managed pointers from rvalues because temporaries cannot be passed by references offering modifiable access.
`operator==`	Return `true` if this managed pointer is empty, and `false` otherwise.
`operator!=`	Return `false` if this managed pointer is empty, and `true` otherwise.

Specializations

Name
`ManagedPtr<TARGET_TYPE volatile>`
`ManagedPtr<TARGET_TYPE&>`
`ManagedPtr<TARGET_TYPE&&>`

Friends

Name Description

BloombergLP::bslma::ManagedPtr This class is a "smart pointer" that refers to a target object accessed via a pointer to the specified parameter type, TARGET_TYPE, and that supports sole ownership of a managed object that is potentially of a different type, and may be an entirely different object from the target object. A managed pointer ensures that the object it manages is destroyed when the managed pointer is destroyed (or re-assigned), using the "deleter" supplied along with the managed object. The target object referenced by a managed pointer may be accessed using either the -> operator, or the dereference operator (operator *). The specified TARGET_TYPE may be const-qualified, but may not be volatile-qualified, nor may it be a reference type.

Name	Description
`BloombergLP::bslma::ManagedPtr`	This class is a "smart pointer" that refers to a target object accessed via a pointer to the specified parameter type, `TARGET_TYPE`, and that supports sole ownership of a managed object that is potentially of a different type, and may be an entirely different object from the target object. A managed pointer ensures that the object it manages is destroyed when the managed pointer is destroyed (or re-assigned), using the "deleter" supplied along with the managed object. The target object referenced by a managed pointer may be accessed using either the `->` operator, or the dereference operator (`operator *`). The specified `TARGET_TYPE` may be `const`-qualified, but may not be `volatile`-qualified, nor may it be a reference type.

Non-Member Functions

Name	Description
`swap`	Efficiently exchange the values of the specified `a` and `b` objects. This function provides the no-throw exception-safety guarantee.