// sample program ; Class.cc   2004.8.10 T. Kondo
// overloading constructor, destructor, virtual function,
// derived class, dynamic object

#include <iostream>
using namespace std;

class Car{
        private:
           int* pN;
        protected:
           double gas;
        public:
           int Npublic ;  // test public number
           //Car(){gas=0; pN=new int[3];}  // default constructor
           Car(double g=999.0);  // This is contructor. overloading with default argument
           ~Car(){delete pN;}    // destructor
           void setGas(double data){gas=data;}
           // void showGas();
           virtual void showGas();
};

class RacingCar:public Car{
        private:
           int course;
        public:
           RacingCar(int c, double g=0);
           void showCourse(){cout<<"course = "<< course << endl;}
           void showGas();    // test overring of member functions
};

void Class()
{
//-----test constructor----
        Car obj;
        cout<<"obj.showGas()  defined via constructor Car::Car(double g)  "; obj.showGas();      //
//-------------------------
        Car mycar;            // define object "mycar" with constructor
        mycar.Npublic = 60;
        cout << "public number Car.Npublic =" << mycar.Npublic << endl;
        mycar.showGas();      //
        mycar.setGas(99.2);   // set gas by 99.2
        mycar.showGas();
        Car mycar2(191.34);   // use overloading constructor
        mycar2.showGas();
//dynamic object
 	cout << "make a dynamic object" << endl;
	Car* pMycar = new Car;  // create new dynamic object
	pMycar->showGas();      // -> because pMycar is pointer.
	pMycar->setGas(12.1);   
	pMycar->showGas();
	delete pMycar;
//overloading constructor
	cout << "using overloading constructor" << endl;
	Car* pMycar2 = new Car(99.02);  // using overloading constructor
	pMycar2->showGas();
	delete pMycar2;
//derived class
	cout << "create a derived class RacingCar" << endl;
	RacingCar myracingcar(12, 122.2);
	myracingcar.showGas();
	myracingcar.showCourse();
//base class pointer pointing the derived class bject
	cout << "base class pointer pointing derived object" << endl;
	Car* pMycar3;
	pMycar3 = &myracingcar;
	pMycar3->showGas();  // if virtual assigned, then RacingCar
        return 0;
}

Car::Car(double g)    // constructor with default argument
{
	gas=g; 
	pN=new int[4];
}  

// define the derived class RacingCar
RacingCar::RacingCar(int c, double g):Car(g)
//RacingCar::RacingCar(int c, double g)
{
	course = c;
}

void Car::showGas()
{
	cout << "gas =" << gas << " (called from base class)" << endl;
}

void RacingCar::showGas()
{
	cout << "gas =" << gas << " (called from derived class)" << endl;

==========================================
[kondo@lxplus770]~/C++% root -l -b -q Class.C

Applying ATLAS style settings...


Processing Class.C...
obj.showGas()  defined via constructor Car::Car(double g)  gas = 999 (called from base class)
public number Car.Npublic =60
gas = 999 (called from base class)
gas = 99.2 (called from base class)
gas = 191.34 (called from base class)
make a dynamic object
gas = 999 (called from base class)
gas = 12.1 (called from base class)
using overloading constructor
gas = 99.02 (called from base class)
create a derived class RacingCar
gas =122.2 (called from derived class)
course = 12
base class pointer pointing derived object
gas =122.2 (called from derived class)