Virtual Function & Dynamic Binding

Programming Language & Its Applications — Virtual Functions and File Handling, NEC licence examination syllabus (Nepal Engineering Council).

Virtual Function and Dynamic Binding

One call site, many behaviours — decided at runtime by the object's actual type, through a table of function pointers.

🌍 Where this lives: dynamic binding is the mechanism behind every plugin, every device driver, and every "render this shape" loop in every graphics engine. When your operating system calls read() on a file descriptor, it does not know whether the target is an SSD, a network socket or a keyboard — a table of function pointers decides at runtime. That is exactly the vtable you are about to see, and Linux implements it by hand in C with struct file_operations. C++ just gave the pattern a keyword. Search "Linux file_operations struct" after this page and you will recognise a hand-rolled vtable immediately — it is the same idea, written out longhand.

Static versus dynamic binding

BINDING = deciding WHICH function a call refers to. STATIC (early) binding — decided at COMPILE time from the declared type of the expression DYNAMIC (late) binding — decided at RUN time from the ACTUAL type of the object C++ uses static binding by DEFAULT. `virtual` opts in to dynamic binding. class Base { public: void f() { cout << "Base"; } }; class Deriv : public Base { public: void f() { cout << "Deriv"; } }; Base *p = new Deriv(); p->f(); → "Base" ← STATIC: p's TYPE is Base* class Base { public: virtual void f() { cout << "Base"; } }; class Deriv : public Base { public: void f() override { cout << "Deriv"; } }; Base *p = new Deriv(); p->f(); → "Deriv" ← DYNAMIC: the OBJECT is Deriv THE THREE REQUIREMENTS for dynamic binding to happen: 1. the base function is declared `virtual` 2. the derived function has the SAME signature (name, parameters, constness) — otherwise it HIDES, not overrides 3. the call goes through a POINTER or REFERENCE to the base Miss any one and you silently get static binding. Base b = derivedObject; /* by VALUE: sliced, static */ b.f(); → "Base", always

binding.cpp

#include <iostream>

class Animal {
public:
    void            eat()   { std::cout << "  Animal eats\n"; }
    virtual void    speak() { std::cout << "  ...\n"; }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void eat()             { std::cout << "  Dog eats bones\n"; }
    void speak() override  { std::cout << "  Woof!\n"; }
};

class Cat : public Animal {
public:
    void eat()             { std::cout << "  Cat eats fish\n"; }
    void speak() override  { std::cout << "  Meow!\n"; }
};

int main() {
    Dog d; Cat c;

    std::cout << "through the object (static both ways):\n";
    d.eat(); d.speak();

    std::cout << "through Animal* :\n";
    Animal *pets[] = { &d, &c };
    for (Animal *a : pets) {
        a->eat();     /* NOT virtual -> always Animal::eat */
        a->speak();   /* virtual     -> the real type wins  */
    }

    std::cout << "through Animal& :\n";
    Animal &ref = d;
    ref.speak();      /* references dispatch too */

    std::cout << "by VALUE (sliced):\n";
    Animal sliced = d;
    sliced.speak();   /* Animal::speak — d's Dog-ness is gone */
    return 0;
}
Output:
through the object (static both ways):
  Dog eats bones
  Woof!
through Animal* :
  Animal eats
  Woof!
  Animal eats
  Meow!
through Animal& :
  Woof!
by VALUE (sliced):
  ...

Three lessons in one output: 1. `a->eat()` printed "Animal eats" for BOTH pets. eat() is not virtual, so the pointer's TYPE decided. Dog::eat and Cat::eat were never called — they merely HIDE the base version. 2. `a->speak()` printed "Woof!" then "Meow!". Same line of source code, two different functions, chosen by what the object actually is. That is polymorphism. 3. `Animal sliced = d;` printed "...". Copying a Dog into an Animal variable keeps only the Animal part — the Dog fields and the vtable pointer are DISCARDED. This is OBJECT SLICING, and it is why polymorphism requires pointers or references, never values.

How it works — the vtable

A class with any virtual function gets a hidden VTABLE: a static array of function pointers, ONE per class (not per object). Each object gets a hidden VPTR pointing at its class's vtable. class Animal { virtual void speak(); virtual ~Animal(); }; class Dog : public Animal { void speak() override; }; Animal's vtable Dog's vtable ┌──────────────────┐ ┌──────────────────┐ │ &Animal::speak │ │ &Dog::speak │ ← replaced │ &Animal::~Animal │ │ &Dog::~Dog │ ← replaced └──────────────────┘ └──────────────────┘ Dog d; d's layout: ┌──────────────┐ │ vptr ────────┼──> Dog's vtable │ (Animal data)│ │ (Dog data) │ └──────────────┘ WHAT `p->speak()` COMPILES TO: 1. load the vptr from the object (1 memory read) 2. load the entry at the vtable's slot 0 (1 memory read) 3. call through that pointer (indirect call) Cost: two extra memory reads plus an indirect call the CPU cannot always predict. Typically a few nanoseconds — and it prevents INLINING, which is often the bigger loss. SIZE COST: one pointer per object (8 bytes on 64-bit), regardless of how many virtual functions exist.

vtable_size.cpp

#include <iostream>

class NoVirtual      { int x;                              };
class OneVirtual     { int x; public: virtual void f() {}   };
class ManyVirtual    { int x; public: virtual void a() {}
                                     virtual void b() {}
                                     virtual void c() {}
                                     virtual void d() {}   };
class DerivedFromOne : public OneVirtual { int y; };

int main() {
    std::cout << "NoVirtual      = " << sizeof(NoVirtual)  << " (int only)\n";
    std::cout << "OneVirtual     = " << sizeof(OneVirtual) << " (int + vptr + pad)\n";
    std::cout << "ManyVirtual    = " << sizeof(ManyVirtual)<< " (STILL one vptr)\n";
    std::cout << "DerivedFromOne = " << sizeof(DerivedFromOne)
              << " (vptr shared, not duplicated)\n";
    return 0;
}
Output:
NoVirtual      = 4 (int only)
OneVirtual     = 16 (int + vptr + pad)
ManyVirtual    = 16 (STILL one vptr)
DerivedFromOne = 16 (vptr shared, not duplicated)

Working out sizeof(OneVirtual) = 16: vptr 8 bytes (at offset 0 on most implementations) int x 4 bytes padding 4 bytes (round up to a multiple of 8, the vptr's alignment) → 16 And ManyVirtual with FOUR virtual functions is also 16. The vtable holds four entries, but the vtable is ONE per class, stored once in the program's data section. Each object still carries just one pointer. That is the key economy: 1000 objects of ManyVirtual cost 1000 × 8 = 8000 bytes of vptr, plus ONE vtable of 4 × 8 = 32 bytes total. Virtual functions scale in classes, not objects.

The jump from 4 to 16 bytes is a 4× size increase on a small class — which is exactly why std::vector, std::string and the other standard containers have no virtual functions at all. For a type meant to be stored by the million, an 8-byte vptr per element is unacceptable. Polymorphism is a tool with a price tag, not a default.

Pure virtual functions and abstract classes

A PURE VIRTUAL function has no body in the base: virtual double area() const = 0; ^^^ "pure specifier" A class with at least one pure virtual function is ABSTRACT: · it CANNOT be instantiated · it CAN have pointers and references to it · a derived class MUST override every pure virtual, or it is abstract too Shape s; ✗ error: cannot declare variable 's' to be of abstract type 'Shape' Shape *p = new Circle(3); ✔ An INTERFACE in C++ is just an abstract class where every function is pure virtual and there is no data — the same role Java's `interface` plays. class Drawable { public: virtual void draw() const = 0; virtual ~Drawable() = default; }; A pure virtual function MAY still have a body, which derived classes can call explicitly — useful for shared default behaviour: virtual void log() const = 0; void Base::log() const { cout << "default"; } /* legal */ /* Derived::log() { Base::log(); ... } */

abstract.cpp

#include <iostream>
#include <memory>
#include <vector>
#include <cmath>

class Shape {
protected:
    std::string name;
public:
    Shape(std::string n) : name(std::move(n)) {}
    virtual double area()      const = 0;   /* pure */
    virtual double perimeter() const = 0;   /* pure */
    virtual ~Shape() = default;

    /* a NON-virtual function using virtual ones —
       the "template method" pattern */
    void report() const {
        std::cout << "  " << name
                  << ": area=" << area()
                  << " perim=" << perimeter()
                  << " ratio=" << area()/perimeter() << "\n";
    }
};

class Circle : public Shape {
    double r;
public:
    explicit Circle(double rad) : Shape("Circle   "), r(rad) {}
    double area()      const override { return M_PI*r*r; }
    double perimeter() const override { return 2*M_PI*r; }
};

class Rectangle : public Shape {
    double w, h;
public:
    Rectangle(double a, double b)
        : Shape("Rectangle"), w(a), h(b) {}
    double area()      const override { return w*h; }
    double perimeter() const override { return 2*(w+h); }
};

class Triangle : public Shape {
    double a, b, c;
public:
    Triangle(double x, double y, double z)
        : Shape("Triangle "), a(x), b(y), c(z) {}
    double perimeter() const override { return a+b+c; }
    double area() const override {
        double s = perimeter()/2;
        return std::sqrt(s*(s-a)*(s-b)*(s-c));
    }
};

int main() {
    /* Shape s("x");   ✗ abstract, cannot instantiate */

    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(3));
    shapes.push_back(std::make_unique<Rectangle>(4, 6));
    shapes.push_back(std::make_unique<Triangle>(3, 4, 5));

    double total = 0;
    for (const auto &s : shapes) { s->report(); total += s->area(); }
    std::cout << "  total area = " << total << "\n";
    return 0;
}
Output:
  Circle   : area=28.2743 perim=18.8496 ratio=1.5
  Rectangle: area=24 perim=20 ratio=1.2
  Triangle : area=6 perim=12 ratio=0.5
  total area = 58.2743

Verifying: Circle r=3 : π·9 = 28.2743, 2π·3 = 18.8496 ratio = 28.2743/18.8496 = 1.5 = r/2 ✔ Rectangle 4×6: 24, 20, ratio 1.2 ✔ Triangle 3,4,5: s=6, √(6·3·2·1)=√36=6, perim 12 ratio 0.5 ✔ total = 28.2743 + 24 + 6 = 58.2743 ✔ The area/perimeter ratio for a circle is exactly r/2 — a neat check that the formulas are right, and a reminder that for a fixed perimeter the circle maximises area (highest ratio of the three). Note report() is NOT virtual, yet it behaves differently for each shape. It calls area() and perimeter(), which ARE virtual. Write the algorithm once in the base, let derived classes supply the steps — that is the Template Method pattern, and it is one of the most useful things virtual functions enable.

Worked example — override, final, and the silent-bug protection

override_kw.cpp

#include <iostream>

class Base {
public:
    virtual void f(int)         { std::cout << "  Base::f(int)\n"; }
    virtual void g() const      { std::cout << "  Base::g() const\n"; }
    virtual void h()            { std::cout << "  Base::h()\n"; }
    virtual ~Base() = default;
};

class Silent : public Base {
public:
    /* ALL THREE are typos that compile as NEW functions,
       silently hiding rather than overriding: */
    void f(double) { std::cout << "  Silent::f(double)\n"; }
    void g()       { std::cout << "  Silent::g()\n"; }
    void H()       { std::cout << "  Silent::H()\n"; }
};

class Safe : public Base {
public:
    void f(int) override { std::cout << "  Safe::f(int)\n"; }
    void g() const override { std::cout << "  Safe::g() const\n"; }
    void h() final { std::cout << "  Safe::h() [final]\n"; }
    /* void f(double) override;  ✗ error: does not override
       void g() override;        ✗ error: const mismatch
       void H() override;        ✗ error: no such base fn  */
};

/* class Deeper : public Safe { void h() override; };
   ✗ error: virtual function 'h' overrides a final function */

int main() {
    Silent s; Safe f;
    Base *p1 = &s, *p2 = &f;

    std::cout << "Silent (typos compiled fine):\n";
    p1->f(7);   p1->g();   p1->h();

    std::cout << "Safe (override enforced):\n";
    p2->f(7);   p2->g();   p2->h();
    return 0;
}
Output:
Silent (typos compiled fine):
  Base::f(int)
  Base::g() const
  Base::h()
Safe (override enforced):
  Safe::f(int)
  Safe::g() const
  Safe::h() [final]

Silent's three functions were meant to be overrides and NONE of them are: f(double) vs f(int) → different parameter type g() vs g() const → different constness H() vs h() → different name (capital H) Each compiled without a single warning, and through a Base* the base versions run. In a large hierarchy this bug is genuinely hard to spot: your derived function simply never gets called. `override` (C++11) makes each of those a COMPILE ERROR. It adds nothing at runtime — it is pure compile-time checking, and it costs one word. Use it on every override, always. `final` prevents further overriding: void h() final; → no derived class may override h class C final { }; → no class may derive from C Beyond documenting intent, `final` lets the compiler DEVIRTUALISE the call — it knows no further override exists, so it can inline it and skip the vtable entirely.

🌍 Go further: the vtable indirection is real but small; what usually costs more is the lost inlining and the unpredictable branch. High-performance C++ therefore often replaces runtime polymorphism with compile-time polymorphism — templates (CRTP) or std::variant plus std::visit — which gets the same flexibility with zero indirection. Game engines and audio code do this routinely. Search "CRTP static polymorphism" and "std::variant vs virtual functions"; comparing the three approaches is one of the better ways to understand what virtual dispatch actually buys you.

💡 Exam angle: define static versus dynamic binding and state the three requirements for dynamic dispatch (virtual in base, matching signature, call via pointer/reference). Explain the vtable and vptr — one table per class, one pointer per object — and be ready to say the size cost is 8 bytes per object regardless of how many virtual functions exist. Pure virtual functions and abstract classes are a guaranteed question: an abstract class cannot be instantiated, and a derived class must override every pure virtual. Also explain object slicing as the reason polymorphism needs pointers.

Syllabus points

Virtual & pure virtual function
Dynamic binding; abstract class; polymorphism

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.