// 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=100.0);  //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
};

int main()
{
        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;
}


**********************************
出力は

public number Car.Npublic =60
gas =100 (called from base class)
gas =99.2 (called from base class)
gas =191.34 (called from base class)
make a dynamic object
gas =100 (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 base class)

となるはず。