Re: Reference Counting

PeterAPIIT@gmail.com wrote:


What about reading a little?


Ok.

 


Way too complicated. Start with a smart pointer that only has different
ownership policies, e.g., a reference counted ownership and a deep copy
policy.


Not good. The operator->() is a typical example of an operator that you will
want a policy to provide. There should be no hard-coded aType in your smart
pointer.


operator* on the other hand, can be defined in terms of operator->() quite
generically as:

  reference operator* ( void ) const {
    return( *( this->operator->() ) );
  }
  

Also: how is smart_ptr supposed to take advantage of all these policies?

[snip lots of "code"]

Maybe, you are in need of an example showing how policies actually can be
used to (a) reuse code that is common and (b) supply the code that differs.
Here is a simple smart pointer with two different ownership models:

#include <algorithm>
#include <functional>
using std::swap;

template < typename T >
class refcounted_policy {

  typedef T value_type;
  typedef value_type * pointer;
  typedef value_type const * const_pointer;

  struct count {
    pointer the_ptr;
    unsigned long ref_count;

    count ( pointer ptr )
      : the_ptr ( ptr )
      , ref_count ( 1 )
    {}

    ~count ( void ) {
      delete ( the_ptr );
    }
    
  };

  count * count_ptr;

public:

  friend
  void swap ( refcounted_policy & lhs, refcounted_policy rhs ) {
    swap( lhs.count_ptr, rhs.count_ptr );
  }
  
  refcounted_policy ( pointer ptr )
    : count_ptr( new count ( ptr ) )
  {}
  
  refcounted_policy ( refcounted_policy const & other )
    : count_ptr ( other.count_ptr )
  {
    ++ count_ptr->ref_count;
  }

  ~refcounted_policy ( void ) {
    -- count_ptr->ref_count;
    if ( count_ptr->ref_count == 0 ) {
      delete( count_ptr );
    }
  }
  
  refcounted_policy & operator= ( refcounted_policy other ) {
    swap ( *this, other );
    return( *this );
  }

  const_pointer operator-> ( void ) const {
    return( count_ptr->t_ptr );
  }
  
  pointer operator-> ( void ) {
    return( count_ptr->t_ptr );
  }

};

template < typename T >
class deepcopy_policy {

  typedef T value_type;
  typedef value_type * pointer;
  typedef value_type const * const_pointer;

  pointer the_ptr;

public:

  friend
  void swap ( deepcopy_policy & lhs, deepcopy_policy rhs ) {
    swap( lhs.the_ptr, rhs.the_ptr );
  }
  
  deepcopy_policy ( pointer ptr )
    : the_ptr( ptr )
  {}
  
  deepcopy_policy ( deepcopy_policy const & other )
    : the_ptr ( other.the_ptr ? new value_type ( *other.the_ptr ) : 0 )
  {}

  ~deepcopy_policy ( void ) {
    delete ( the_ptr );
  }
  
  deepcopy_policy & operator= ( deepcopy_policy other ) {
    swap ( *this, other );
    return( *this );
  }

  const_pointer operator-> ( void ) const {
    return( the_ptr );
  }
  
  pointer operator-> ( void ) {
    return( the_ptr );
  }
  
};

template < typename T,
           template <class> class ownership_policy >
class smart_ptr :
  public ownership_policy< T >
{

  typedef ownership_policy< T > ownership;
  
public:

  typedef T value_type;
  typedef value_type * pointer;
  typedef value_type const * const_pointer;
  typedef value_type & reference;
  typedef value_type const & const_reference;

  smart_ptr ( pointer ptr = 0 )
    : ownership ( ptr )
  {}

  const_reference operator* ( void ) const {
    return( *( this->operator->() ) );
  }
  
  reference operator* ( void ) {
    return( *( this->operator->() ) );
  }

  friend
  bool operator== ( smart_ptr const & lhs, smart_ptr const & rhs ) {
    return ( lhs.operator->() == rhs.operator->() );
  }
  
  friend
  bool operator!= ( smart_ptr const & lhs, smart_ptr const & rhs ) {
    return ( lhs.operator->() != rhs.operator->() );
  }
  
  friend
  bool operator< ( smart_ptr const & lhs, smart_ptr const & rhs ) {
    return ( std::less<pointer>
             ( lhs.operator->(), rhs.operator->() ) );
  }

  friend
  bool operator<= ( smart_ptr const & lhs, smart_ptr const & rhs ) {
    return ( std::less_equal<pointer>
             ( lhs.operator->(), rhs.operator->() ) );
  }

  
  friend
  bool operator> ( smart_ptr const & lhs, smart_ptr const & rhs ) {
    return ( std::greater<pointer>
             ( lhs.operator->(), rhs.operator->() ) );
  }

  friend
  bool operator>= ( smart_ptr const & lhs, smart_ptr const & rhs ) {
    return ( std::greater_equal<pointer>
             ( lhs.operator->(), rhs.operator->() ) );
  }
    
};

#include <iostream>

struct Base {

  Base ( void ) {
    std::cout << "base is born.\n";
  }
  
  Base ( Base const & other ) {
    std::cout << "base is copied.\n";
  }
  
  virtual ~Base () {
    std::cout << "base dies.\n";
  }

  friend
  std::ostream & operator<< ( std::ostream & ostr,
                              Base const & obj ) {
    return( ostr << "base" );
  }
  
};

int main ( void ) {
  {
    smart_ptr< Base, deepcopy_policy > a_ptr ( new Base() );
    smart_ptr< Base, deepcopy_policy > b_ptr ( a_ptr );
    smart_ptr< Base, deepcopy_policy > c_ptr ( a_ptr );
    a_ptr = smart_ptr< Base, deepcopy_policy >();
    std::cout << "first handle deleted.\n";
    b_ptr = smart_ptr< Base, deepcopy_policy >();
    std::cout << "second handle deleted.\n";
  }
  std::cout << "------------------------\n";
  {
    smart_ptr< Base, refcounted_policy > a_ptr ( new Base() );
    smart_ptr< Base, refcounted_policy > b_ptr ( a_ptr );
    smart_ptr< Base, refcounted_policy > c_ptr ( a_ptr );
    a_ptr = smart_ptr< Base, refcounted_policy >();
    std::cout << "first handle deleted.\n";
    b_ptr = smart_ptr< Base, refcounted_policy >();
    std::cout << "second handle deleted.\n";
  }
}

Note that derived classes are not handled correctly (true cloning is missing
from the deepcopy policy). Also, there is no support for incomplete types.
In short, many things that you would expect from a good smart pointer are
missing.

Best

Kai-Uwe Bux