| Home | Libraries | People | FAQ | More

## Class template intrusive_ptr

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::intrusive::pointer_traits< VoidPointer >::template rebind_pointer< T >::type pointer;       // Provides the type of the internal stored pointer.
      typedef T                                                                                   element_type;  // Provides the type of the stored pointer.

      // 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 &);
    };

## 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(to_raw_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(to_raw_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(to_raw_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(to_raw_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