![]() |
Home | Libraries | People | FAQ | More |
boost::interprocess::shared_ptr
// In header: <boost/interprocess/smart_ptr/shared_ptr.hpp> template<typename T, typename VoidAllocator, typename Deleter> class shared_ptr { public: // types typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; // construct/copy/destruct (); (, = , = ); (shared_ptr &); (shared_ptr &, ); template<typename Y> (shared_ptr< ); template<typename Y> (weak_ptr< ); (shared_ptr &&); template<typename Y> shared_ptr & (shared_ptr< ); shared_ptr & (shared_ptr)); shared_ptr & (shared_ptr &&); // public member functions (); template<typename Pointer> (, = , = ); template<typename Y> (shared_ptr< , ); () ; () ; () ; () ; () ; () ; (shared_ptr< ); };
shared_ptr stores a pointer to a dynamically allocated object. The object pointed to is guaranteed to be deleted when the last shared_ptr pointing to it is destroyed or reset.
shared_ptr is parameterized on T (the type of the object pointed to), VoidAllocator (the void allocator to be used to allocate the auxiliary data) and Deleter (the deleter whose operator() will be used to delete the object.
The internal pointer will be of the same pointer type as typename VoidAllocator::pointer type (that is, if typename VoidAllocator::pointer is offset_ptr<void>, the internal pointer will be offset_ptr<T>).
Because the implementation uses reference counting, cycles of shared_ptr instances will not be reclaimed. For example, if main() holds a shared_ptr to A, which directly or indirectly holds a shared_ptr back to A, A's use count will be 2. Destruction of the original shared_ptr will leave A dangling with a use count of 1. Use weak_ptr to "break cycles."
shared_ptr
public
construct/copy/destruct();
Constructs an empty shared_ptr
. Use_count() == 0 && get()== 0.
( p, a = , d = );
Constructs a shared_ptr
that owns the pointer p. Auxiliary data will be allocated with a copy of a and the object will be deleted with a copy of d. Requirements: Deleter and A's copy constructor must not throw.
(shared_ptr & r);
Copy constructs a shared_ptr
. If r is empty, constructs an empty shared_ptr
. Otherwise, constructs a shared_ptr
that shares ownership with r. Never throws.
(shared_ptr & other, p);
Constructs a shared_ptr
that shares ownership with other and stores p. Postconditions: get() == p && use_count() == r.use_count(). Throws: nothing.
template<typename Y> (shared_ptr< r);
If r is empty, constructs an empty shared_ptr
. Otherwise, constructs a shared_ptr
that shares ownership with r. Never throws.
template<typename Y> (weak_ptr< r);
Constructs a shared_ptr
that shares ownership with r and stores a copy of the pointer stored in r.
(shared_ptr && other);
Move-Constructs a shared_ptr
that takes ownership of other resource and other is put in default-constructed state. Throws: nothing.
template<typename Y> shared_ptr & (shared_ptr< r);
Equivalent to shared_ptr(r).swap(*this). Never throws
shared_ptr & (shared_ptr) r);
Equivalent to shared_ptr(r).swap(*this). Never throws
shared_ptr & (shared_ptr && other);
Move-assignment. Equivalent to shared_ptr(other).swap(*this). Never throws
shared_ptr
public member functions();
This is equivalent to: this_type().swap(*this);
template<typename Pointer> ( p, a = , d = );
This is equivalent to: this_type(p, a, d).swap(*this);
template<typename Y> (shared_ptr< r, p);
() ;
Returns a reference to the pointed type
() ;
Returns the pointer pointing to the owned object
() ;
Returns the pointer pointing to the owned object
() ;
Not operator. Returns true if this->get() != 0, false otherwise
() ;
Returns use_count() == 1. unique() might be faster than use_count()
() ;
Returns the number of shared_ptr
objects, *this included, that share ownership with *this, or an unspecified nonnegative value when *this is empty. use_count() is not necessarily efficient. Use only for debugging and testing purposes, not for production code.
(shared_ptr< other);
Exchanges the contents of the two smart pointers.