CLASS TEMPLATE(3)

NAME
boost::interprocess::intrusive_ptr

SYNOPSIS

// In header: <boost/interprocess/smart_ptr/intrusive_ptr.hpp>
template<typename T, typename VoidPointer>
class intrusive_ptr {
public:
  // types
  typedef boost::pointer_to_other< VoidPointer, T >::type pointer;                // Provides the type of the internal stored pointer.
  typedef T                                               element_type;           // Provides the type of the stored pointer.
  typedef VoidPointer                                     VP;                     // @ private:
  typedef intrusive_ptr                                   this_type;
  typedef pointer this_type::*                            unspecified_bool_type;
  // construct/copy/destruct
  intrusive_ptr();
  intrusive_ptr(const pointer &, bool = true);
  intrusive_ptr(intrusive_ptr const &);
  template<typename U> intrusive_ptr(intrusive_ptr< U, VP > const &);
  intrusive_ptr& operator=(intrusive_ptr const &);
  template<typename U>
    intrusive_ptr& operator=(intrusive_ptr< U, VP > const &);
  intrusive_ptr& operator=(pointer);
  ~intrusive_ptr();
  // public member functions
  pointer & get();
  const pointer & get() const;
  T & operator*() const;
  const pointer & operator->() const;
  pointer & operator->();
  operator unspecified_bool_type() const;
  bool operator!() const;
  void swap(intrusive_ptr &);
  pointer m_ptr;  // @ private:
};

DESCRIPTION

The intrusive_ptr class template stores a pointer to an object with an embedded reference count. intrusive_ptr is parameterized on T (the type of the object pointed to) and VoidPointer(a void pointer type that defines the type of pointer that intrusive_ptr will store). intrusive_ptr<T, void *> defines a class with a T* member whereas intrusive_ptr<T, offset_ptr<void> > defines a class with a offset_ptr<T> member. Relies on unqualified calls to:

void intrusive_ptr_add_ref(T * p); void intrusive_ptr_release(T * p);

with (p != 0)

The object is responsible for destroying itself.

  intrusive_ptr public construct/copy/destruct

    1.

    intrusive_ptr();

    Constructor. Initializes internal pointer to 0. Does not throw

    2.

    intrusive_ptr(const pointer & p, bool add_ref = true);

    Constructor. Copies pointer and if "p" is not zero and "add_ref" is true calls intrusive_ptr_add_ref(get_pointer(p)). Does not throw

    3.

    intrusive_ptr(intrusive_ptr const & rhs);

    Copy constructor. Copies the internal pointer and if "p" is not zero calls intrusive_ptr_add_ref(get_pointer(p)). Does not throw

    4.

    template<typename U> intrusive_ptr(intrusive_ptr< U, VP > const & rhs);

    Constructor from related. Copies the internal pointer and if "p" is not zero calls intrusive_ptr_add_ref(get_pointer(p)). Does not throw

    5.

    intrusive_ptr& operator=(intrusive_ptr const & rhs);

    Assignment operator. Equivalent to intrusive_ptr(r).swap(*this). Does not throw

    6.

    template<typename U>
      intrusive_ptr& operator=(intrusive_ptr< U, VP > const & rhs);

    Assignment from related. Equivalent to intrusive_ptr(r).swap(*this). Does not throw

    7.

    intrusive_ptr& operator=(pointer rhs);

    Assignment from pointer. Equivalent to intrusive_ptr(r).swap(*this). Does not throw

    8.

    ~intrusive_ptr();

    Destructor. If internal pointer is not 0, calls intrusive_ptr_release(get_pointer(m_ptr)). Does not throw

  intrusive_ptr public member functions

    1.

    pointer & get();

    Returns a reference to the internal pointer. Does not throw

    2.

    const pointer & get() const;

    Returns a reference to the internal pointer. Does not throw

    3.

    T & operator*() const;

    Returns *get(). Does not throw

    4.

    const pointer & operator->() const;

    Returns *get(). Does not throw

    5.

    pointer & operator->();

    Returns get(). Does not throw

    6.

    operator unspecified_bool_type() const;

    Conversion to boolean. Does not throw

    7.

    bool operator!() const;

    Not operator. Does not throw

    8.

    void swap(intrusive_ptr & rhs);

    Exchanges the contents of the two smart pointers. Does not throw