Ch 6. Virtual Functions

4 hours · 5 marks

6.1 What is a Virtual Function

A virtual function is a member function declared in a base class using the keyword virtual, which is expected to be redefined in derived classes. When called through a base class pointer/reference, the actual (derived) object's version is invoked — this is resolved at run time (late binding), not compile time.

class Shape {
public:
    virtual void draw() { cout << "Drawing shape"; }
};
class Circle : public Shape {
public:
    void draw() override { cout << "Drawing circle"; }   // overrides base version
};

6.2 Need of Virtual Function

Without virtual, calling a function through a base class pointer always invokes the base class's version (early/static binding), regardless of the actual object type — this defeats runtime polymorphism.

Shape *s = new Circle();
s->draw();   // WITHOUT virtual: calls Shape::draw()
              // WITH virtual:    calls Circle::draw()  -- correct runtime polymorphism

Virtual functions let a single interface (base class pointer) work correctly for objects of many derived types — the foundation of runtime polymorphism.

6.3 Pointer to Derived Class

A base class pointer can point to a derived class object (upcasting is implicit and safe), but a derived class pointer cannot directly point to a base object without an explicit (and potentially unsafe) downcast.

Shape *sp;
Circle c;
sp = &c;        // OK -- base pointer to derived object (upcasting)
sp->draw();     // calls Circle::draw() if draw() is virtual
// Circle *cp = sp;          -> error, needs explicit cast
Circle *cp = static_cast<Circle*>(sp);  // downcast (use dynamic_cast for safety)

6.4 Array of Pointers to Base Class

A common OOP pattern: store an array of base class pointers, each pointing to a different derived object, then call the virtual function uniformly on each — every call automatically dispatches to the correct derived version.

Shape *shapes[3];
shapes[0] = new Circle();
shapes[1] = new Square();
shapes[2] = new Triangle();
for (int i = 0; i < 3; i++)
    shapes[i]->draw();     // each call resolves to the correct derived draw()

6.5 Pure Virtual Functions and Abstract Class

A pure virtual function has no implementation in the base class and is declared with = 0. A class containing at least one pure virtual function becomes an abstract class — it cannot be instantiated directly, and serves only as a base for derived classes, which must override the pure virtual function(s) to become concrete (instantiable).

class Shape {
public:
    virtual void draw() = 0;    // pure virtual function
};
// Shape s;  -> ERROR: cannot instantiate abstract class
class Circle : public Shape {
public:
    void draw() override { cout << "Circle"; }   // must override to be concrete
};

6.6 Virtual Destructors

If a base class is meant to be used polymorphically (deleted through a base pointer), its destructor must be declared virtual. Otherwise, deleting a derived object through a base pointer invokes only the base destructor, causing the derived part's resources to leak (undefined behaviour).

class Base {
public:
    virtual ~Base() { cout << "Base dtor"; }   // virtual destructor
};
class Derived : public Base {
public:
    ~Derived() { cout << "Derived dtor"; }
};
Base *p = new Derived();
delete p;   // with virtual ~Base(): calls Derived dtor then Base dtor (correct)
             // without virtual: would call ONLY Base dtor -- leak/bug

6.7 Reinterpret Cast Operator

reinterpret_cast performs a low-level reinterpretation of the bit pattern of an object — e.g., converting a pointer of one unrelated type to another, or a pointer to an integer. It performs no type checking or conversion logic and should be used sparingly since it can produce unsafe/undefined results if misused.

int a = 65;
int *p = &a;
char *c = reinterpret_cast<char*>(p);   // reinterprets the pointer's bit pattern

6.8 Run-time Type Information (RTTI)

RTTI allows the type of an object to be determined during program execution. C++ provides two RTTI facilities:

• typeid operator — returns a type_info object identifying an expression's type: cout << typeid(*ptr).name();
• dynamic_cast — safely converts a base class pointer/reference to a derived type, returning nullptr (for pointers) or throwing std::bad_cast (for references) if the conversion is invalid. Requires the base class to be polymorphic (have at least one virtual function).

Shape *s = new Circle();
Circle *c = dynamic_cast<Circle*>(s);
if (c) cout << "Successfully cast to Circle";
else cout << "Cast failed";

Most Probable Questions

class Animal {
public:
    virtual void sound() { cout << "Some sound"; }
};
class Dog : public Animal {
public:
    void sound() override { cout << "Bark"; }
};
class Cat : public Animal {
public:
    void sound() override { cout << "Meow"; }
};
int main() {
    Animal *a;
    Dog d; Cat c;
    a = &d; a->sound();  // Bark
    a = &c; a->sound();  // Meow
}