// 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() {
cout << " String ctor (def):" << endl;
str_ = NULL;
}
String( const char* in ) {
cout << " String ctor: " << in << '.' << endl;
str_ = new char[strlen(in) + 1];
strcpy( str_, in );
}
String( String& str ) {
cout << " String ctor (copy): " << str.str_ << '.' << endl;
str_ = new char[strlen(str.str_) + 1];
strcpy( str_, str.str_ );
}
~String() {
cout << " String dtor: " << str_ << '.' << endl;
delete str_;
}
String& operator= ( String& rhs ) {
if (this == &rhs) return *this;
delete str_;
str_ = new char[strlen(rhs.str_) + 1];
strcpy( str_, rhs.str_ );
return *this;
}
private:
char* str_;
};

ostream& operator << ( ostream& os, String& str ) { return os << str.str_; }

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.