Cpp Counted Pointer Implementation

Here is a simple implementation of counted_ptr. I adapted it from the original counted_ptr proposal to the CeePlusPlus Standard. I'm not sure why it was vetoed, probably because AutoPtr was sufficient and they wanted to move on with the process. Personally, I prefer using an explicit reference and referent pair. For example, in CppUtxOverview, the abstract component, utx::ITest would inherit from an abstract IReferent class. Then, all occurrences of counted_ptr<ITest> would be changed to Reference_<ITest>. This requires less overhead since Reference_<T> can count on T already being a referent rather than having to aggregate a pointer into the referent pointer.

I haven't compiled this for a while so if you find any errors or think of any improvements, simply fix this code.

 /*
 * Name....: counted_ptr.h
 * Date....: 07/24/99
 * Created.: RobertDiFalco
 *
 * Implementation of the counted_ptr specification. Uses a ''static 
 * default'' referent to improve the performance when being default
 * constructed by an array or collection.
 *
 *   #define XXX_USE_COPY_ON_WRITE
 *
 * Define the above constant if you wish to enable the
 * counted_ptr::isolate member. This clones the shared pointer
 * with its copy constructor and then isolates from the rest of
 * its references. This is useful for using counted_ptr as the
 * base for a string class that uses copyOnWrite for its non-
 * const members.
 */

 #ifndef __COUNTED_PTR_H
 #define __COUNTED_PTR_H

 template< class E >
 class counted_ptr
 {
     /// Interface.

     public:

         typedef E       element_type;       // counted object type
         typedef size_t  size_type;          // count type


         // assignment ctor: e.g. counted_ptr<Foo> foo_ref = new Foo();
         explicit
         counted_ptr( element_type* ptr = 0 )
         {
             // NOTE: speeds default creation for arrays
             static referent s_rep( 0, 1 ); // NOTE: stack gets a ref

             reference(
                 ( ptr == 0 )
                     ? &s_rep
                     : new referent( ptr ) );
         }

         // copy ctor: 
         counted_ptr( const counted_ptr<E>& rhs )
         {
             reference( rhs.m_pRep );
         }

         // assignment 
         counted_ptr<E>& operator=( const counted_ptr<E>& rhs )
         {
             if ( m_pRep != rhs.m_pRep )
                 reset( rhs.m_pRep );

             return *this;
         }

         ~counted_ptr()
         {
             release();
         }

         element_type& operator*() const
         {
             return *get();
         }

         element_type* operator->() const
         {
             return get();
         }

         element_type* get() const
         {
             return m_pRep->m_ptr;
         }

         bool is_unique() const
         {
             return m_pRep->m_nCount == 1;
         }


     #ifdef XXX_USE_COPY_ON_WRITE

         void isolate()
         {
             if ( is_unique() )    // nothing to do
                 return;

             /* NOTE: if this fails, the state of the object must
             continue to be sound. The only problem areas are the
             new operations (and possibly the delete called by
             ::release). Basically, we treat the code like a
             transaction. */

             // throws out of isolate if error creating element
             element_type* ptr = new element_type( *get() );

             try
             {
                 /* NOTE: This is safe if the new operation
                 fails. If success, it does a simple release
                 and reference call. */

                 reset( new referent( ptr ) );
             }
             catch( ... )
             {
                 delete ptr;
                 throw;                     // propagate
             }
         }

     #endif//XXX_USE_COPY_ON_WRITE

     /// Implementation.

     private:

         // the referenced representation

         struct referent
         {
             referent( element_type* ptr = 0, size_t nCount = 0 ) :
                 m_ptr( ptr ),
                 m_nCount( nCount )
             {
             }

             ~referent()
             {
                 delete m_ptr;
             }

             element_type* m_ptr;      // the actual object
             size_t        m_nCount;   // number of references
         } 
         * m_pRep;                     // this referenced pointer


         //..Simple methods to reference and release reps

         /* NOTE: these should use critical sections */

         void reset( referent* pRep )
         {
             ''// :$: auto_lock< lock_type > lock;

             release();
             reference( pRep );
         }

         void reference( referent* pRep )
         {
             (m_pRep = pRep)->m_nCount++;
         }

         void release()
         {
             if ( --m_pRep->m_nCount == 0 )
                 delete m_pRep;
         }
 };

 #endif//__COUNTED_PTR_H

-- RobertDiFalco

---

There is also the BoostSharedPtr implementation available from the BoostLibraries. It's been debugged and tested. -- JasonRiedy

Does this implementation provide any benefits over BoostSharedPtr? Given that BoostSharedPtr has been accepted as part of TechnicalReportOne, it seems like a better long-term solution.

The use of PolicyBasedClassDesign would make it easy to have a compile time switch to compare implementations. -- JohnFletcher

See also: ReferenceCounting, SmartPointer

---

CategoryCpp CategoryGarbageCollection CategoryPointer