// sample program ; CopyConstructor.cc   2004.8.22 2008.10.17v1 T. Kondo

#include <iostream.h>
#include <string>
using namespace std;

class Car{
	private:
	   char* pName;
	protected:
	   double gas;
	public:
           Car();
	   Car(char* pN,double g);  // constructor
           Car(const Car& c);    // copy constructor
	   Car& operator=(const Car& c);
	   ~Car();    // destructor
	   void showCar();
};


int main()
{
        cout <<"-------object construction with default argument------"<<endl;
        Car mycar;   // define object "mycar" with constructor
        mycar.showCar();

        cout <<"-------object construction with input arguments-----"<<endl;
        Car mycar1("this is mycar. ", 90.2349);   // mycar1 with input argument
        mycar1.showCar();      //

        cout <<"-------object copy via copy constructor--------"<<endl;
        Car mycar2 = mycar1;   // this is "initialization" by copy constructor
        mycar2.showCar();      //

        cout <<"-------object copy via assignment--------"<<endl;
        Car mycar3;
        mycar3 = mycar2;      // this is a copy via assignment operator
        mycar3.showCar();
        cout << "-------------end of job----------------"<<endl;
        return 0;
}

Car::Car()    // constructor with default argument
{
	gas=0;
	pName=new char[strlen("no name car")+1];
	strcpy(pName,"no name car");
	cout << "default constructor: " << pName << endl;
}  

Car::Car(char* pN, double g)    // constructor with input argument
{
	gas=g; 
	pName=new char[strlen(pN)+1];
	strcpy(pName,pN);
	cout << "constructor: " << pName << endl;
}  

// copy constructor
Car::Car(const Car& c)    
{
	cout << "copy constructor is operated here" << endl;
	gas = c.gas;
	pName = new char[strlen("copy of ")+strlen(c.pName)+1];
	strcpy(pName, "copy of ");
	strcat(pName, c.pName);
	cout << "dynamic object :" << pName << " created" << endl;
}

// assignment operator for copy via assignment  (a=b)
Car& Car::operator=(const Car& c)    
{
	cout << "assignment operator activated here:" << endl;
	if(this != &c){
	delete[] pName;
	pName = new char[strlen("copy of ")+strlen(c.pName)+1];
	strcpy(pName, "copy of ");
	strcat(pName, c.pName);
	gas = c.gas;
	}
	return *this;
}


Car::~Car()    // destructor
{
	cout << "destructor done:" << pName << endl;
	delete pName;
}  

void Car::showCar()
{
	cout << "number, gas =" << pName << ", "<<gas<< endl;
}


---------CopyConstructor.ccの出力結果------------------------------

-------object construction with default argument------
default constructor: no name car
number, gas =no name car, 0
-------object construction with input arguments-----
constructor: this is mycar.
number, gas =this is mycar. , 90.2349
-------object copy via copy constructor--------
copy constructor is operated here
dynamic object :copy of this is mycar.  created
number, gas =copy of this is mycar. , 90.2349
-------object copy via assignment--------
default constructor: no name car
assignment operator activated here:
number, gas =copy of copy of this is mycar. , 90.2349
-------------end of job----------------
destructor done:copy of copy of this is mycar.
destructor done:copy of this is mycar.
destructor done:this is mycar.
destructor done:no name car