Question

I read so many blogs and I understand how to use virtual function in c++. But, still I don’t understand why we use virtual functions. Can you give me a real world example so that I can more easily visualize the actual meaning of virtual function.

Answer 1

An important thing to mention is that inheritance (which the keyword virtual is fundamental for) should not be for the sole purpose of code re-use, use delegation for this.

Delegation would be when we have a class say BroadbandConnection with a method called connection(). Then your manager says we want to add encryption, so you create a class BroadbandConnectionWithEncryption. Your natural instinct may be to use inheritance and then make the new class BroadbandConnectionWithEncryption derive from BroadbandConnection.

Drawback’s to this is that the creator of the initial class had not designed it for inheritance so you would need to change its definition to make the method connection() virtual so you can override its behavior in the derived class. This is not always ideal. A better idea is to use delegation here for the purpose of code reuse.

class BroadBandConnection
{
public:
    void Connection (string password)
    {
        //connection code.
    }
};

class BroadBandConnectionWithEndcryption
{
public:
    void Connection (string password)
    {
        mbroadbandconnection.Connection(password);
        //now do some stuff to zero the memory or
        //do some encryption stuff
    }

private:
    BroadBandConnection mbroadbandconnection;
};

The keyword virtual is used for the purpose of polymorphism. As the name suggest, it is the ability for an object to have more than one form. This sort of decision would be made at the time of designing an interface or class.

class IShape
{
    virtual void Draw () = 0; 
};

class Square
{
    void Draw()
    {
        //draw square on screen 
    }
};

class Circle
{
    void Draw()
    {
        //draw circle on screen
    }
};

I made Draw() pure virtual with the = 0. I could have left this out and added some default implementation. Pure virtual makes sense for Interfaces where there is no reasonable default implementation.

What this lets me do is pass around a Shape object to various methods and they do not need to be concerned with what I have just given them. All they know is that I have to provide something that supports the ability for a shape to draw itself.

IShape* circle = new Circle ();
IShape* square = new Square ();

void SomeMethod (IShape* someShape)
{
   someShape->Draw(); //This will call the correct functionality of draw
}

In the future as people begin thinking of new shapes, they can derive from IShape and so long as they implement some functionality for Draw. They can pass this object to SomeMethod.