AutoRCObject.cpp

#include <iostream.h>

// Implements reference counting ( Item 29 ). From More Effective C++

// Implements a base class for reference counting called RCObject

// The reference count is now modified automatically by the wrapper RCPtr
// that in this case makes pointers to Sting::StringValue smart.

// See also:
//	> Reference.cpp*
//	> RCObject.cpp

class RCObject
{
 protected:
 RCObject();
 RCObject( const RCObject& rhs );
 RCObject& operator=( const RCObject& rhs );
 virtual ~RCObject () = 0;
 
 public: 
 
 void addReference ();
 void removeReference();
 
 void markUnshareable();
 bool isShareable() const;
 
 bool isShared ()const;
 
 private:
 int refCount;
 bool shareable;
};

RCObject::RCObject()
 :refCount(0), shareable(true) {}
 
RCObject::RCObject( const RCObject& )
 :refCount(0), shareable(true){}
 
RCObject& RCObject::operator=( const RCObject& )
{ return *this; }

RCObject::~RCObject() {}

void RCObject::addReference() { refCount++; }

void RCObject::removeReference() 
{ if ( --refCount == 0 ) delete this; }

void RCObject::markUnshareable ( )
 { shareable = false; }
 
bool RCObject::isShareable() const
 { return shareable; }
 
bool RCObject::isShared() const
 { return refCount > 1; }

template <class T>
class RCPtr
{
 public:
 RCPtr(T* realPtr=0 );
 RCPtr(const RCPtr& rhs);
 ~RCPtr();
 
 RCPtr& operator=(const RCPtr& rhs);
 
 T* operator->() const;
 T& operator*() const;
 
 private:
 
 T *pointee;
 void init();
};

template<class T>
RCPtr<T>::RCPtr(T *realPtr):pointee(realPtr)
{
 init();
}

template<class T>
RCPtr<T>::RCPtr(const RCPtr& rhs):pointee(rhs.pointee)
{
 init();
}

template<class T>
void RCPtr<T>::init()
{
 if ( pointee == 0 )
 return;
 
 if ( pointee->isShareable() == false )
 {
 pointee = new T(*pointee);
 }
 pointee->addReference();
}

template<class T>
RCPtr<T>& RCPtr<T>::operator=( const RCPtr& rhs )
{
 if ( pointee == rhs.pointee )
 return *this;
 
 if ( pointee )
 {
 pointee->removeReference();
 }
 
 pointee = rhs.pointee;
 init();
 return *this;
}

template<class T>
RCPtr<T>::~RCPtr()
{
 if ( pointee ) pointee->removeReference();
}

template<class T>
T* RCPtr<T>::operator->() const { return pointee; }

template<class T>
T& RCPtr<T>::operator*() const { return *pointee; }

class String
{
 public:
 String ( const char *initValue = "" );
 const char& operator [] ( int index ) const;
 char& operator[] ( int index );
 void Print ( );
 private:
 struct StringValue: public RCObject
 {
 char *data;
 StringValue( const char *initValue );
 StringValue( const StringValue& rhs );
 ~StringValue ( );
 };
 RCPtr<StringValue> value;	 	 
};

String::StringValue::StringValue ( const char *initValue )
{
 data = new char [strlen (initValue) + 1];
 strcpy(data, initValue);
}

String::StringValue::StringValue( const StringValue& rhs )
{
 data = new char[strlen(rhs.data) + 1];
 strcpy(data, rhs.data);
}

String::StringValue::~StringValue()
{
 delete [] data;
}

String::String( const char *initValue )
 :value ( new StringValue ( initValue ) )
 {}
 
const char& String::operator [] ( int index ) const
{
 return value->data[index];
}

char& String::operator[] ( int index )
{
 if ( value->isShared( ) )
 {
 value = new StringValue ( value->data );
 }
 value->markUnshareable();
 return value->data[index]; 
}

void String::Print()
{
 cout << "Data: " << value->data << endl;
 cout << "Shared: " << value->isShared() << endl;
 cout << "Shareable: " << value->isShareable() << endl << endl;
}

int main ()
{
 String s1("More Effective C++");
 String s2("Hello");
 cout << s1[1] << endl;
 char *p = &s1[1];
 s2 = s1;
 *p = 'x';
 s1.Print();
 s2.Print();
}