virtual functions

The following example might help illustrate the advantages of such a concept:

#include <iostream>
#include <vector>
using namespace std;

#include <stdlib.h>
#include <time.h>


struct IVehicle {

virtual void Drive () = 0;
virtual void Release () = 0;
};

class Car : public IVehicle {

public:

virtual ~Car() {}

virtual void Drive () { cout << "Driving a car" << endl;}
virtual void Release () {delete this;}
};

class Bus : public IVehicle {

public:

virtual ~Bus() {}

virtual void Drive () { cout << "Driving a Bus" << endl;}
virtual void Release () {delete this;}
};

int main () {

vector<IVehicle*> vVehicles;
vector<IVehicle*>::iterator i;

srand((unsigned)time(NULL));

for ( int n = 0; n < 10; ++n) {

  int nDice = rand() % 10;

  if ( nDice >= 5)
    vVehicles.push_back(new Car);
  else
    vVehicles.push_back(new Bus);
}

for (i = vVehicles.begin(); i != vVehicles.end(); ++i) {

  (*i)->Drive();
  (*i)->Release();
 
}

return 0;
}

Select allOpen in new window

why some one wants to declare a pointer of parent class type object and define it for a child class object.

Look at it from a real world perspective

Lets say you initially design a "Father" class and then create an object of it. The Father has certain characteristics or properties. Now your client application may have been using only the Father class and referring to its behaviour by calling functions defined in the Father class.

A "Son" object is created later. There will be something in common between Father and Son to the extent that the Son can be considered as being similar to the Father or even a type of "Father".
Let's take the example of "Walk" being a characteristic which both Father and Son have. Now you have defined a function "Walk" in Father and have called it in your client application in several places.

Sometime in the future you decide that you want to replace the Father's walk with the Son's walk and so then all you need to do is use the same Father pointer in your client application but just initialize it with a "Son" object.

Now because "Walk" was a virtual function you automatically end up calling Son's Walk function wherever Father's Walk was called.


This is putting it in very layman terms.

If you want to read up about virtual functions you also need to understand inheritance.

http://www.cplusplus.com/doc/tutorial/inheritance/
http://www.cplusplus.com/doc/tutorial/polymorphism/

class Father{

public :

virtual Walk();
};

class Son : public Father {

public:
virtual Walk();
};

//below is your client app
main()
{

Father* aFamily = new Father; //or new Son();

aFamily->Walk(); //calls Father->Walk() or Son->Walk()

delete aFamily;
aFamily = 0;

}

Select allOpen in new window