How you can override base class member in derived classexplain with example?

Answer 1

To override a base class method you simply need to declare the base class method as being virtual. As well as creating a v-table, this also gives a visual hint to other developers that you expect the function to be overridden. The v-table ensures that all calls to the base class method are routed to the derived class method, thus ensuring objects behave polymorphically, according to their actual type, and not what we're actually pointing at.

Consider the following example:

#include <iostream>

class base

{

public:

virtual ~base();

virtual void PrintMe() const { std::cout << "I am a base class!" << std::endl; }

};

class derived: public base

{

public:

void PrintMe() const { std::cout << "I am a derived class!" << std::endl; }

};

int main()

{

base b;

derived d;

base* pb = &d;

b.PrintMe();

d.PrintMe();

pb->PrintMe();

return( 0 );

}

Output:

I am a base class!

I am a derived class!

I am a derived class!

Note that although pb points to the base class instance of d, it still knows that it really is a derived class, as can be seen from the third line of output.

Now try removing the virtual keyword from the base class method. The output will change as follows:

Output:

I am a base class!

I am a derived class!

I am a base class!

Now your derived class thinks it is a base class. This is because the v-table no longer has no entry for that method, and therefore the call cannot be routed to the overridden derived class method. The base class method is called because that's what we're actually pointing at and the object no longer behaves polymorphically according to its actual type.

Note also that if any method is declared virtual in a class, the class constructor must also be declared virtual. If you fail to do this, your classes will not be destroyed properly. The virtual keyword ensures that the most-derived class is always destroyed first, before working up the hierarchy of destructors to eventually destroy the least-derived class, the base class itself.

Consider the following example without a virtual destructor:

#include <iostream>

class base

{

public:

base(){ std::cout << "Base class created" << std::endl; }

~base(){ std::cout << "Base class destroyed" << std::endl; }

};

class derived: public base

{

public:

derived(){ std::cout << "Derived class created" << std::endl; }

~derived(){ std::cout << "Derived class destroyed" << std::endl; }

};

int main()

{

derived* d = new derived();

base* b = d;

delete( b );

return( 0 );

}

Output:

Base class created

Derived class created

Base class destroyed

As you can see, the derived class was created but was not destroyed. We've created a memory leak: that memory cannot be recovered until the program ends.

Now add the virtual keyword to the base class destructor:

#include <iostream>

class base

{

public:

base(){ std::cout << "Base class created" << std::endl; }

virtual ~base(){ std::cout << "Base class destroyed" << std::endl; }

};

class derived: public base

{

public:

derived(){ std::cout << "Derived class created" << std::endl; }

~derived(){ std::cout << "Derived class destroyed" << std::endl; }

};

int main()

{

derived* d = new derived();

base* b = d;

delete( b );

return( 0 );

}

Output:

Base class created

Derived class created

Derived class destroyed

Base class destroyed

Now we have the expected behaviour and have resolved the memory leak. Remember, if ANY method of a class is declared virtual, the destructor must also be declared virtual.

Note that although derived classes need not use the virtual keyword in front of overrides (it is implied by the base class), there is no harm in explicitly declaring them as such, if only to give a visual hint that the methods are expected to be overridden by derivatives of the derivative (multi-level inheritance).