// Purpose.  Proxy design pattern lab (reference counting)// // Discussion.  One of the four common situations in which the Proxy pattern is// applicable is as a "smart reference" - a replacement for a bare pointer that// performs additional actions when an object is referenced.  Here, that addi-// tional action is "reference counting".  The original String class becomes// the inner "body" class.  A "count" data member is added to the body class.// A new outer "handle" class is created that contains a pointer to a body// instance.  Body instances common to multiple handle instances are shared by// simply incrementing the reference count.  As these shared references go away,// the reference count is decremented.  When the count goes to zero, the body// instance is freed.  This mechanism allows the "reference counted class" to// perform simple-minded garbage collection on itself.// // Assignment.// o Change the class String to an inner body StringRep.// o Add a count_ private data member to StringRep.  Initialize count_ to 1 in//   the default ctor and the 1-arg ctor.// o Create a new outer handle class String. Make String a friend of StringRep.// o String has one private data member - a pointer to a StringRep (rep_).// o The String default ctor initializes rep_ with 'new StringRep("")'.// o The String 1-arg ctor initializes rep_ with 'new StringRep(arg)'.// o The String copy ctor initializes rep_ with the rep_ of the initializing//   String.  It also increments the count_ of that rep_.// o The String dtor decrements the count_ of rep_ and deletes rep_ if count_//   is 0.
// o The String operator=(): increments the count_ of the "rhs" rep_,
//   decrements the count_ of its own rep_ and deletes rep_ if count_ is 0,
//   assigns the "rhs" rep_ to its own rep_, and returns *this.
// o Add cout statements to String to generate the target output.
// o Make the operator<<() function a friend of both StringRep and String.//   Modify it as necessary.#include <iostream.h>#include <string.h>
class String {
public:
	friend ostream& operator << ( ostream&, String& );
	String() { 
		rep = new StringRep(""); 
        cout << "     String ctor (def):" << endl;
	}
	String(const char * in) { 
		rep = new StringRep( in ) ; 
		cout << "     String ctor: " << in << '.' << endl;
	}
    String(const String& s)  { 
		rep = s.rep;
		s.rep->count++;
		cout << "     String (copy): " << s.rep->str_ << '.' << endl;
	}
	String& operator= ( String& rhs ) {
		if (this == &rhs)  return *this;
		rhs.rep->count++;
		rep->count--;
		if(0 == rep->count ) { if( rep ) delete rep; rep = NULL; }
		rep = rhs.rep;
		return *this;
	}
	~String() {
		rep->count--;
		if(rep->count + 1){
			cout << "      String dtor: " << rep->str_ << ", before decrement, count is " 
				<< rep->count + 1 << endl;			
		}
		if(!rep->count ) { if( rep ) delete rep;}
	}
	
	class StringRep {
	public:
		friend class String;
		//		friend ostream& operator << ( ostream&, String& );
		StringRep() {
			cout << "   StringRep ctor (def):" << endl;
			str_ = NULL;
			count = 1;
		}
		StringRep( const char* in ) {
			cout << "   StringRep ctor: " << in << '.' << endl;
			str_ = new char[strlen(in) + 1];
			strcpy( str_, in );
			count = 1;
		}
		StringRep( StringRep& str ) {
			cout << "   StringRep ctor (copy): " << str.str_ << '.' << endl;
			str_ = new char[strlen(str.str_) + 1];
			strcpy( str_, str.str_ );
			count = 1;
		}
		char *getString()    { return str_; }
		~StringRep() {
			cout << "   StringRep dtor: " << str_ << '.' << endl;
			delete str_;
		}
		StringRep& operator= ( StringRep& rhs ) {
			if (this == &rhs)  return *this;
			delete str_;
			str_ = new char[strlen(rhs.str_) + 1];
			strcpy( str_, rhs.str_ );
			return *this;
		}
	private:
		char*  str_;
		int count;
	};
	private:
		StringRep *rep;
};ostream& operator << ( ostream& os, String& str ) { return os << str.rep->getString(); }void main( void ) {	String  a( "hello" );
	String  b = "world";
	String  c( a );
	String  d = a;
	String  e;
	a = b;
	e = b;	cout << "a is " << a << '.' << endl;	cout << "b is " << b << '.' << endl;	cout << "c is " << c << '.' << endl;	cout << "d is " << d << '.' << endl;	cout << "e is " << e << '.' << endl;}/****** Current output ******///    String ctor: hello.//    String ctor: world.//    String ctor (copy): hello.//    String ctor (copy): hello.//    String ctor (def):// a is world.// b is world.// c is hello.// d is hello.// e is world.//    String dtor: world.//    String dtor: hello.//    String dtor: hello.//    String dtor: world.//    String dtor: world./****** Target output ******///    StringRep ctor: hello.// String ctor: hello.//    StringRep ctor: world.// String ctor: world.// String ctor (copy): hello.// String ctor (copy): hello.//    StringRep ctor: .// String ctor (def)://    StringRep dtor: .// a is world.// b is world.// c is hello.// d is hello.// e is world.// String dtor: world, before decrement, count is 3// String dtor: hello, before decrement, count is 2// String dtor: hello, before decrement, count is 1//    StringRep dtor: hello.// String dtor: world, before decrement, count is 2// String dtor: world, before decrement, count is 1//    StringRep dtor: world.