Question

Let’s say that you’re on a system where you cant use TR1, boost, etc. You just have the straight-up standard library C++.

If you were stuck with this scenario, what’s the simplest reference-counting smart-pointer you could use? (our system only has auto_ptr which is not overly useful).

I’m happy with a link to something somewhat well-established or a simple “it’s too complicated to implement yourself” if that’s the answer (which I’m half expecting 🙁 ).

Answer 1

Well some time ago I just made one for studding interest. It’s not so “smart” but anyway better then raw pointer.

class CReferenceCount
{
private:
    unsigned int m_count;

public:
   CReferenceCount() : m_count(0) { }
   virtual ~CReferenceCount() { }

   void increseRef()
   {
      ++m_count;
   }

   unsigned int decreseRef()
   {
      return --m_count;
   }
};

class CCustomDeleter
{
public:
  template<typename T>
  void operator()(const T* ptr) const
  {
      delete ptr; ptr = NULL;
  }

  void operator()(const char* ptr) const
  {
     delete[] ptr; ptr = NULL;
  }
};

template <typename T>
class CWrapPtr
{
private:
 void makeRefCountObj()
 {
    try
    {
        m_rcPtr = new CReferenceCount();
    }
    catch (std::bad_alloc &err)
    {
        std::cout<<"-- CWrapPtr : "<<err.what()<<std::endl;
        // should do something about failed CWrap object...
    }

    m_rcPtr->increseRef();
 }

 public:
  T *m_objPtr;
  CReferenceCount *m_rcPtr;


  CWrapPtr() : m_objPtr(NULL), m_rcPtr(NULL)
  {
     makeRefCountObj();
  }

  CWrapPtr(T *obj) : m_objPtr(obj), m_rcPtr(NULL)
  {
     makeRefCountObj();
  }

  virtual ~CWrapPtr()
  {
    if (m_rcPtr && m_rcPtr->decreseRef() == 0)
    {
        CCustomDeleter dd;
        dd(m_objPtr);

        delete m_rcPtr; m_rcPtr = NULL;
    }
  }

  CWrapPtr(const CWrapPtr<T> &other) : m_objPtr(other.m_objPtr),
                                     m_rcPtr(other.m_rcPtr)
  {
      m_rcPtr->increseRef();
  }


T& operator*()
{
    assert(m_objPtr != NULL);
    return *m_objPtr;
}

T* operator->()
{
    assert(m_objPtr != NULL);
    return m_objPtr;
}

CWrapPtr<T>& operator=(const CWrapPtr<T> &other)
{
    if (this != &other)
    {

        if (m_rcPtr && m_rcPtr->decreseRef() == 0)
        {
            CCustomDeleter dd;
            dd(m_objPtr);

            delete m_rcPtr; m_rcPtr = NULL;
        }

        m_objPtr = other.m_objPtr;
        m_rcPtr = other.m_rcPtr;

        m_rcPtr->increseRef();
    }

    return *this;
 }
};

And yeah it’s just demo..