Polymorphism in C++: one call, many behaviors

Polymorphism in C++ means that one call can run different code depending on the type it is used with. At run time, a call to a virtual function through a base-class pointer or reference runs the version that belongs to the object’s real class. At compile time, overloaded functions and templates pick the code from the argument types.

Two shapes in a list, as a whole program:

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

constexpr double pi = 3.14159265358979;

struct Shape {
    virtual double area() const { return 0.0; }
    virtual ~Shape() = default;
};

struct Circle : Shape {
    explicit Circle(double r) : radius{r} {}
    double area() const override { return pi * radius * radius; }
    double radius;
};

struct Square : Shape {
    explicit Square(double s) : side{s} {}
    double area() const override { return side * side; }
    double side;
};

int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(1.0));
    shapes.push_back(std::make_unique<Square>(2.0));

    for (const auto& shape : shapes) {
        std::cout << shape->area() << '\n';  // one call, two results
    }
}

It printed:

3.14159
4

Circle and Square are derived classes of Shape, the base class: they inherit from it, and each overrides area, replacing the base’s version with its own (inheritance in C++ covers what else a derived class gets). The vector holds std::unique_ptr<Shape>, smart pointers to the base that delete their objects. The loop makes one call, shape->area(), and each object runs its own area.

The samples are C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and all four printed the same. override dates from C++11 (Since When lists the first compiler releases with it).

What makes a call polymorphic in C++?

Three things, all at once:

• the function is declared virtual in the base class;
• the derived class overrides it, with the same name, parameters and const;
• the call goes through a pointer or a reference to the base, as shape->area() does.

Then the call runs the version that belongs to the object’s own class, its dynamic type, rather than to the type the pointer was declared with, its static type ([class.virtual]).

Take virtual off Shape::area, and override off the two derived functions, and the same loop runs the base version both times:

struct Shape {
    double area() const { return 0.0; }  // no virtual
    virtual ~Shape() = default;
};
// ...
for (const auto& shape : shapes) {
    std::cout << shape->area() << '\n';  // Shape::area both times
}

It printed:

0
0

Without virtual, the type the pointer was declared with decides, and that type is Shape. All four compilers built it without a warning.

What is runtime polymorphism in C++?

Runtime polymorphism in C++, also called dynamic or late binding, is a virtual function called through a base-class pointer or reference. Which version runs is decided while the program runs, from the object it points at, so the same loop works for any class derived from Shape. Write override on each function that overrides, so the compiler rejects one that does not match the base. This area forgets const, so it overrides nothing:

struct Circle : Shape {
    explicit Circle(double r) : radius{r} {}
    // error: const is missing, so this overrides nothing
    double area() override { return pi * radius * radius; }
    double radius;
};

All four rejected it. GCC said:

error: 'double Circle::area()' marked 'override', but does not override

A function marked override that overrides nothing does not compile, and neither does overriding a function marked final. The derived function is virtual whether or not it says so; the C++ Core Guidelines (C.128) ask for exactly one of virtual, override and final on each virtual function.

The C++ virtual functions answer goes further: pure virtual functions with a body and virtual calls in constructors.

What is compile-time polymorphism in C++?

Compile-time polymorphism, also called static polymorphism, is the compiler choosing the function from the types in the call. Function overloading and templates do it, with no base class and no virtual.

Function overloading is one name with several parameter lists. Overload resolution, the compiler’s matching step, picks the function whose parameters match the arguments most closely:

void print(int value) {
    std::cout << "print(int): " << value << '\n';
}

void print(double value) {
    std::cout << "print(double): " << value << '\n';
}

void print(const std::string& value) {
    std::cout << "print(string): " << value << '\n';
}
// ...
const std::string name = "square";
print(4);        // print(int)
print(3.14159);  // print(double)
print(name);     // print(string)

It printed:

print(int): 4
print(double): 3.14159
print(string): square

Only the parameters count: two functions that differ in their return type alone cannot overload each other. Overloaded operators such as + and << are chosen the same way (operator overloading in C++).

A function template is one function written once for many types. The compiler writes a separate function, an instantiation, for each set of argument types the template is called with:

template <typename T>
T larger(T a, T b) {
    return a > b ? a : b;
}
// ...
const std::string circle = "circle";
const std::string square = "square";
std::cout << larger(2, 4) << '\n';             // T is int
std::cout << larger(1.5, 0.5) << '\n';         // T is double
std::cout << larger(circle, square) << '\n';   // T is std::string

It printed 4, 1.5 and square.

What are the common polymorphism mistakes?

Three, and two of them compiled without a warning on all four compilers.

Slicing: a derived object passed by value

Passing or storing a Circle by value as a Shape copies only its Shape part, which is called slicing, and the copy runs Shape::area:

void describe(Shape shape) {  // a copy of the Shape part only
    std::cout << shape.area() << '\n';
}

void describe_ref(const Shape& shape) {  // the Circle itself
    std::cout << shape.area() << '\n';
}
// ...
Circle circle{1.0};
describe(circle);      // 0
describe_ref(circle);  // 3.14159

It printed 0, then 3.14159, and none of the four compilers warned about describe(circle). Take polymorphic objects by reference or pointer. By value, in the Core Guidelines’ words, “only the base portion of a derived object will be copied, and the polymorphic behavior will be corrupted” (C.67).

A base function that is not virtual

Leave virtual out of the base class and every call through a Shape pointer runs Shape::area, as the loop without virtual printed, again with no warning. Writing override on the derived functions catches it: with no virtual area in the base to override, all four compilers rejected them.

A base destructor that is not virtual

delete through a Shape* runs both destructors when the base class’s destructor is virtual:

struct Shape {
    virtual double area() const { return 0.0; }
    virtual ~Shape() { std::cout << "~Shape\n"; }
};

struct Circle : Shape {
    explicit Circle(double r) : radius{r} {}
    double area() const override { return pi * radius * radius; }
    ~Circle() { std::cout << "~Circle\n"; }
    double radius;
};
// ...
Shape* shape = new Circle{1.0};
delete shape;  // ~Circle, then ~Shape

It printed ~Circle, then ~Shape. Without virtual on ~Shape, the same delete is undefined behavior, which means the standard sets no rule for what the program does ([expr.delete]), so that version was compiled and never run. GCC and both Clangs warned about it; MSVC said nothing at /W4. The running example’s virtual ~Shape() = default; is the fix (C++ Core Guidelines C.35).

What is an abstract class in C++?

An abstract class is a class with at least one pure virtual function, declared with = 0: you cannot create an object of it, only of derived classes that override that function. In the first example Shape::area has a body that returns 0; make it pure, and Shape shape; stops compiling:

struct Shape {
    virtual double area() const = 0;  // pure virtual: no body
    virtual ~Shape() = default;
};
// ...
Shape shape;  // error: Shape is abstract

All four rejected it. Clang said:

error: variable type 'Shape' is an abstract class

Pointers and references to an abstract class are still allowed, and they are all that runtime polymorphism needs.

Compile-time vs runtime polymorphism

A std::variant read with std::visit (both C++17) is another way, for a fixed set of types that need no common base: std::visit calls a function with the value the variant holds. More answers about the core language are in Language.