//Ch9Demo.cpp 
//SYSC 2002, Fall 2009
//A simple example of when and how c++ uses destructors, copy constructors,
//and the assignment operator.
#include "stdstuff.h"
//very simple class, no private data.
class DemoClass{
    public:
        int someInt;
        int* aIntPtr;
        //Default constructor. C++ uses this whenever it needs to construct an
        //instance of the DemoClass class (ie create a DemoClass object)
        DemoClass(){ 
            cout << "Calling default constructor." <<endl;
            someInt=0;
            // allocates space on the heap for a single int.
            aIntPtr = new int;
            // set what aIntPtr points to, to 0;
            *aIntPtr = 0;
        }
        //Parameterized constructor, a user will call this to create a new 
        //object. Added for the examples in main().
        DemoClass(int a, int b){
            cout << "Calling parameterized constructor." << endl;
            someInt=a;
            // allocates space on the heap for a single int.
            aIntPtr = new int;
            // set what aIntPtr points to, to b;
            *aIntPtr = b;
        }
        //Since the class has a pointer (most likely allocates from the heap in
        //the constructor) you will NEED the following three methods or you may
        //get buggy code. c++ uses them implicitily (see main()).
        ~DemoClass(){
            cout << "Calling implicit destructor!" << endl;
            delete aIntPtr;
        }
        
        
        DemoClass& operator=(const DemoClass& rightHandSideOfOperator){
            cout << "Calling overloaded = operator!" << endl;
            someInt = rightHandSideOfOperator.someInt;
            // space has already been allocated on the heap for a single int,
            // so just change the value.
            *aIntPtr = *(rightHandSideOfOperator.aIntPtr);
            return *this;
        }
        
        DemoClass(const DemoClass &objectToCopyDataFrom){
            cout << "Calling copy constructor!" << endl;
            someInt = objectToCopyDataFrom.someInt;
            // allocates space on the heap for a single int.
            aIntPtr = new int;
            *aIntPtr = *(objectToCopyDataFrom.aIntPtr); 
        }
        
        
};

// useless function to show implicit copy constructor call.
// passing an object of class DemoClass by value, therefore
// copy constructor is implicitlly called to create the copy 
// that foo will work with. Any modifications to object a in this function
// cannot have an effect outside the function!
void foo(DemoClass a){
    //do nothing, since a is no longer needed, a's destructor will be
    //implicitly called.
    cout << endl << "set parameter's aIntPtr to point to 53" << endl;
    (*a.aIntPtr)=53;
}
        
int main(){
    
    DemoClass ob1;
    cout << "ob1 should be 0, 0." << endl;
    cout << "ob1.someInt=" << ob1.someInt << endl;
    cout << "*(ob1.aIntPtr)=" << *(ob1.aIntPtr) << endl << endl;
    
    DemoClass ob2(10,10);
    cout << "ob2 should be 10, 10." << endl;
    cout << "ob2.someInt=" << ob2.someInt << endl;
    cout << "*(ob2.aIntPtr)=" << *(ob2.aIntPtr) << endl;
    
    cout << endl;
    
    //if assignment operator is not overloaded the following will 
    //happen in the default = operator.
    // ob1.someInt=ob2.someInt
    // ob1.aIntPtr=ob2.aIntPtr
    // But we dont want to copy over the actual pointer value! We want to copy
    // what the pointer points to!
    cout << "Comment out operator= and see what happens when we do assignment: ob2=ob1" << endl;
    ob2 = ob1;
    
    cout << "ob1.someInt=" << ob1.someInt << endl;
    cout << "*(ob1.aIntPtr)=" << *(ob1.aIntPtr) << endl;
    cout << "ob2.someInt=" << ob2.someInt << endl;
    cout << "*(ob2.aIntPtr)=" << *(ob2.aIntPtr) << endl;
    
    cout << endl << "change *(ob1.aIntPtr) to 35" << endl;
    *(ob1.aIntPtr) = 35;
    
    cout << "ob1.someInt=" << ob1.someInt << endl;
    cout << "*(ob1.aIntPtr)=" << *(ob1.aIntPtr) << endl;
    cout << "ob2.someInt=" << ob2.someInt << endl;
    cout << "*(ob2.aIntPtr)=" << *(ob2.aIntPtr) << endl;
    
    cout << endl;
        
    
    //Lets see when the copy constructor is called. If we never had a copy
    //constructor modifications to *ob1.aIntPtr would have an effect outside
    //the function call!
    // check obj1 before function:
    cout << "Comment out  destructor and copy constructor and see what happens" << endl;
    cout << "when we pass ob1 to foo by value:" << endl;
    cout << "ob1 before calling foo:" << endl;
    cout << "ob1.someInt=" << ob1.someInt << endl;
    cout << "*(ob1.aIntPtr)=" << *(ob1.aIntPtr) << endl;
    foo(ob1);
    // and after
    cout << "ob1 after calling foo:" << endl;
    cout << "ob1.someInt=" << ob1.someInt << endl;
    cout << "*(ob1.aIntPtr)=" << *(ob1.aIntPtr) << endl;
    
    cout << endl;
    
    //Three things are going to happen in the following one line of code!
    // 1. DemoClass(1000,1000) creates a new DemoClass object and keeps track
    //    of it without you knowing it (c++'s implicit copy)! It is an implicit 
    //    copy of what DemoClass(1000,1000) does. Therefore parameterized 
    //    constructor is called.
    // 2. The implicit copy is then assigned to ob1. If the = operator is not
    //    overloaded the default = will be used, in other words:
    //    ob1.someInt=(c++'s implicit copy).someInt
    //    ob1.aIntPtr=(c++'s implicit copy).aIntPtr
    // 3. The destructor is called for (c++'s implicit copy).
    //    If the ob1.aIntPtr is de-referenced and we did a shallow copy using
    //    the default = operator this will cause us to access something that
    //    has been unallocated! Bad news indeed.
    
    ob1 = DemoClass(1000,1000);
    
    cout << "ob1.someInt=" << ob1.someInt << endl;
    cout << "*(ob1.aIntPtr)=" << *(ob1.aIntPtr) << endl;
    
    
    pause();
    return 0;              
}