What Is Virtual Function In C++

6 min read

Virtual functions are the cornerstone of runtime polymorphism in C++, enabling a program to decide which function to execute based on the actual type of an object rather than the type of the pointer or reference used to call it. This mechanism allows developers to write flexible, extensible code where a base class defines a common interface while derived classes provide specific implementations. Understanding how virtual functions work, why they are necessary, and how the compiler implements them under the hood is essential for mastering object-oriented design in C++ Worth keeping that in mind. Less friction, more output..

The Problem: Static Binding vs. Dynamic Binding

To appreciate virtual functions, one must first understand the default behavior of C++: static binding (also known as early binding). When you call a member function using a pointer or reference to a base class, the compiler resolves the call at compile time based on the static type of the pointer.

Consider a classic scenario involving a Shape base class and Circle and Rectangle derived classes That's the part that actually makes a difference. No workaround needed..

class Shape {
public:
    void draw() { 
        std::cout << "Drawing a generic shape\n"; 
    }
};

class Circle : public Shape {
public:
    void draw() { 
        std::cout << "Drawing a circle\n"; 
    }
};

class Rectangle : public Shape {
public:
    void draw() { 
        std::cout << "Drawing a rectangle\n"; 
    }
};

If you write a function that accepts a Shape* and calls draw():

void render(Shape* s) {
    s->draw(); // Static binding occurs here
}

int main() {
    Circle c;
    Rectangle r;
    render(&c); // Output: "Drawing a generic shape"
    render(&r); // Output: "Drawing a generic shape"
}

The output is disappointing. Now, it ignores the fact that s actually points to a Circle or Rectangle object. Because draw() is a non-virtual function, the compiler sees the parameter Shape* s and binds the call to Shape::draw(). This is static binding—the function call is "glued" to the pointer type during compilation Most people skip this — try not to..

The Solution: The virtual Keyword

By adding the virtual keyword to the base class declaration, you instruct the compiler to perform dynamic binding (late binding). The function call is resolved at runtime based on the dynamic type of the object (the actual object being pointed to) Easy to understand, harder to ignore..

class Shape {
public:
    virtual void draw() { // Now virtual
        std::cout << "Drawing a generic shape\n"; 
    }
    virtual ~Shape() {} // Critical: Virtual destructor
};

With this single change, the render function now produces the correct output:

  • render(&c) prints "Drawing a circle"
  • render(&r) prints "Drawing a rectangle"

The compiler generates code to look up the correct function address at runtime. This lookup mechanism is the heart of polymorphism.

Under the Hood: The Virtual Table (vtable) and Virtual Pointer (vptr)

How does C++ achieve this runtime magic? The standard does not mandate a specific implementation, but virtually every compiler uses the Virtual Table (vtable) and Virtual Pointer (vptr) mechanism.

The Virtual Table (vtable)

For every class that declares or inherits virtual functions, the compiler creates a static array of function pointers—this is the vtable. Each entry in this table points to the virtual function implementation appropriate for that specific class Easy to understand, harder to ignore. Surprisingly effective..

  • Shape has a vtable with an entry pointing to Shape::draw().
  • Circle has its own vtable with an entry pointing to Circle::draw().
  • Rectangle has a vtable pointing to Rectangle::draw().

The Virtual Pointer (vptr)

When you create an object of a class with virtual functions, the compiler silently inserts a hidden member variable into the class layout: the vptr. This pointer is initialized in the constructor to point to the vtable of that specific class.

Memory layout conceptually looks like this:

  • Shape object: [ vptr -> Shape::vtable ] [ Shape data members ]
  • Circle object: [ vptr -> Circle::vtable ] [ Shape data members ] [ Circle data members ]

The Dispatch Process

When you call s->draw() on a Shape*:

  1. The compiler generates code to follow the vptr inside the object s points to.
  2. It accesses the vtable associated with the actual object (e.g., Circle::vtable).
  3. It finds the offset for draw() (usually index 0 or 1).
  4. It jumps to the function address stored at that offset.

This indirection adds a negligible performance cost (one pointer dereference) but provides immense architectural flexibility And that's really what it comes down to. Worth knowing..

Pure Virtual Functions and Abstract Classes

A pure virtual function is a virtual function that has no implementation in the base class and must be overridden in any concrete derived class. You declare it by assigning 0 in the declaration:

class Shape {
public:
    virtual void draw() = 0; // Pure virtual function
    virtual double area() = 0; 
    virtual ~Shape() {}
};

A class containing at least one pure virtual function becomes an Abstract Class. It exists solely to define an interface contract. You cannot instantiate an abstract class directly (Shape s; is a compile error). This forces derived classes like Circle and Rectangle to provide concrete logic for draw() and area(), ensuring the interface is fully implemented The details matter here..

The Critical Rule: Virtual Destructors

One of the most common and dangerous pitfalls in C++ involves destructors. If a class has any virtual functions, its destructor must be virtual.

class Base {
public:
    Base() { std::cout << "Base Constructor\n"; }
    ~Base() { std::cout << "Base Destructor\n"; } // Non-virtual!
};

class Derived : public Base {
public:
    Derived() { std::cout << "Derived Constructor\n"; }
    ~Derived() { std::cout << "Derived Destructor\n"; }
};

int main() {
    Base* ptr = new Derived();
    delete ptr; // Undefined behavior / Resource leak risk
}

Output with non-virtual destructor:

Base Constructor
Derived Constructor
Base Destructor   <-- Derived destructor NOT called!

Because delete is called on a Base*, static binding applies to the destructor if it isn't virtual. That's why only Base::~Base() runs. If Derived allocated memory (e.That said, g. , new int[100]), that memory leaks.

Output with virtual ~Base():

Base Constructor
Derived Constructor
Derived Destructor
Base Destructor

Dynamic binding ensures the correct destructor chain executes: most-derived first, then base. Always declare destructors virtual in polymorphic base classes.

The override and final Specifiers (C++11 and Beyond)

Modern C++ provides tools to catch errors at compile time rather than runtime The details matter here..

override

Use override in the derived class declaration. It explicitly tells the compiler: "I intend to override a virtual function from the base class." If the signature doesn't match exactly (e.g., a typo in the name, different const-ness, or different parameter types), the compiler emits an error.

class Circle : public Shape {
public:
    void draw() override { // Compiler checks signature matches Shape::draw()
        std::cout << "Drawing a circle\n"; 
    }
    // void draw(int x) override; // ERROR: Signature mismatch
};

final

Use final to prevent further overriding in subsequent derived classes or to prevent a class from being inherited entirely.

class FinalCircle : public Shape {
public:
    void draw() final override; // No class inheriting from FinalCircle can override draw()
};

Just Hit the Blog

Just Dropped

Others Explored

Readers Loved These Too

Thank you for reading about What Is Virtual Function In C++. We hope the information has been useful. Feel free to contact us if you have any questions. See you next time — don't forget to bookmark!
⌂ Back to Home