IntrusivePtr.h

Go to the documentation of this file.

#ifndef IntrusivePtr_HEADER
#define IntrusivePtr_HEADER

/***************************************************************************
 * Benoit Hudson (C) 2007.
 ***************************************************************************/

namespace hudson {

/***************************************************************************
 * An implementation of a boost-like intrusive shared pointer.
 *
 * It's not clear how the boost intrusive_ptr could possibly work holding
 * templated types.  Here I redo it in a more limited setting.
 *
 * Standard usage would be:
 * class Foo  {
 *   int refcount;
 *   friend class hudson::IntrusivePtr<Foo>;
 *   static void add_ref(Foo *f) { f->refcount++; }
 *   static void release(Foo *f) { f->refcount--; if (f->refcount == 0) { delete f; } }
 *   public:
 *   Foo(): refcount(0) { }
 * };
 * class Bar  {
 *   hudson::IntrusivePtr<Foo> f;
 * };
 *
 * If you don't have access to write the add_ref/release functions into the
 * object (or if T is a base type), specify a different class that has those
 * two static functions.
 ***************************************************************************/
template <class T, class AddRelease=T>
class IntrusivePtr {
  T *ptr_;

  void addref() {
    if (ptr_) {
      AddRelease::add_ref(ptr_);
    }
  }
  void delref() {
    if (ptr_) {
      AddRelease::release(ptr_);
    }
  }

  public:
  IntrusivePtr(): ptr_(0) { }
  IntrusivePtr(T *p): ptr_(p) { addref(); }
  IntrusivePtr(const IntrusivePtr& other): ptr_(other.get()) { addref(); }
  ~IntrusivePtr() { delref(); }

  IntrusivePtr& operator= (T *p) {
    /* don't delref/addref if we're reassigning (we might hold the only reference!). */
    if (p == ptr_) { return *this; }
    delref();
    ptr_ = p;
    addref();
    return *this;
  }
  IntrusivePtr& operator= (const IntrusivePtr& other) {
    return this->operator= (other.get());
  }

  T *get() const {
    return ptr_;
  }

  T& operator*() const {
    return *ptr_;
  }

  T *operator->() const {
    return ptr_;
  }

  operator bool() const {
    return ptr_ != 0;
  }

  bool operator== (const T* p) const { return ptr_ == p; }
  bool operator!= (const T* p) const { return ptr_ != p; }

  bool operator== (const IntrusivePtr& p) const { return ptr_ == p.get(); }
  bool operator!= (const IntrusivePtr& p) const { return ptr_ != p.get(); }
};

} // namespace hudson

#endif

---