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