ПолиморфизмPolymorphism

Полиморфизм («много форм») — свойство кода работать одинаково с объектами разных типов через общий интерфейс, вызывая у каждого объекта именно его собственную реализацию операции. В C++ это не одна возможность, а две принципиально разные: динамическая (что вызывать — решается в рантайме, через virtual) и статическая (что вызывать — решается на этапе компиляции, через шаблоны/перегрузку).Polymorphism ("many forms") is code's ability to work uniformly with objects of different types through a shared interface, while each object runs its own specific implementation of an operation. In C++ this isn't one capability but two fundamentally different ones: dynamic (what to call is decided at runtime, via virtual) and static (what to call is decided at compile time, via templates/overloading).

struct Shape { virtual double area() const = 0; virtual ~Shape() = default; };
struct Circle : Shape { double r; double area() const override { return 3.14159 * r * r; } };
struct Square : Shape { double side; double area() const override { return side * side; } };

void printArea(const Shape& s) {
    std::cout << s.area();   // один и тот же вызов, разный результат в зависимости от реального типа s// the same call, a different result depending on s's actual type
}
printArea(Circle{{}, 2});   // напечатает площадь круга// prints the circle's area
printArea(Square{{}, 3});   // та же функция printArea — напечатает площадь квадрата// the same printArea function — prints the square's area

printArea написана один раз в терминах Shape и ничего не знает ни про Circle, ни про Square — это и есть суть полиморфизма: код, зависящий от интерфейса, а не от конкретного типа. Ниже — как именно C++ реализует это через virtual (динамически) и как альтернативно через шаблоны (статически), и что каждый вариант стоит по производительности.printArea is written once in terms of Shape and knows nothing about either Circle or Square — that's the essence of polymorphism: code that depends on an interface, not a concrete type. Below is exactly how C++ implements this via virtual (dynamically), the template-based alternative (statically), and what each option costs in performance.

Виртуальная функция разрешается не по статическому типу указателя/ссылки, а по реальному типу объекта, на который он указывает — и это разрешение происходит в рантайме через таблицу виртуальных функций (подробный разбор устройства — на отдельной странице).A virtual function is resolved not by the static type of the pointer/reference, but by the actual type of the object it points to — and that resolution happens at runtime via a virtual function table (the detailed mechanics live on a dedicated page).

struct Shape {
    virtual double area() const = 0;
    virtual ~Shape() = default;
};
struct Circle : Shape {
    double r;
    double area() const override { return 3.14159 * r * r; }
};
struct Square : Shape {
    double side;
    double area() const override { return side * side; }
};

double totalArea(const std::vector<std::unique_ptr<Shape>>& shapes) {
    double sum = 0;
    for (const auto& s : shapes) sum += s->area();  // какая area() вызовется — решается в рантайме// which area() runs is decided at runtime
    return sum;
}

Ключевое свойство: totalArea компилируется один раз и работает с любым будущим наследником Shape, даже написанным в другой единице трансляции или подключённым позже как плагин через динамическую библиотеку. Это и есть настоящий полиморфизм в духе runtime-расширяемости.The key property: totalArea is compiled once and works with any future descendant of Shape, even one written in a different translation unit or loaded later as a plugin via a shared library. That's genuine polymorphism in the runtime-extensibility sense.

Шаблоны и перегрузка дают «один интерфейс — много реализаций» без единого виртуального вызова: компилятор подставляет конкретный тип уже на этапе компиляции (монорфизация), генерируя отдельную специализацию функции под каждый использованный тип.Templates and overloading provide "one interface, many implementations" without a single virtual call: the compiler substitutes the concrete type at compile time (monomorphization), generating a separate specialization of the function for each type actually used.

template<typename T>
double totalArea(const std::vector<T>& shapes) {
    double sum = 0;
    for (const auto& s : shapes) sum += s.area();  // прямой вызов — T::area известен на этапе компиляции// a direct call — T::area is known at compile time
    return sum;
}
// totalArea<Circle>(...) и totalArea<Square>(...) — две разные функции в бинарнике// totalArea<Circle>(...) and totalArea<Square>(...) are two separate functions in the binary

Здесь s.area() — прямой вызов известной на этапе компиляции функции, полностью доступный для инлайнинга. Плата за это — totalArea должна быть скомпилирована заново (как минимум — инстанцирована) для каждого нового T, и вызывающий код обязан знать конкретный тип на этапе компиляции: смешать Circle и Square в одном std::vector<T> нельзя — для этого и нужен динамический полиморфизм.Here s.area() is a direct call to a function known at compile time, fully available for inlining. The price is that totalArea must be compiled anew (at minimum, instantiated) for every new T, and the calling code must know the concrete type at compile time: you can't mix Circle and Square in one std::vector<T> — that's exactly what dynamic polymorphism is for.

• cppreference — Virtual function specifier
• cppreference — Constraints and concepts