Зачем нужны виртуальные функции в C++? Объясните на примере

Суть проблемы: статическое vs динамическое связывание

Ваш код не работает как ожидалось, потому что в C++ по умолчанию используется раннее (статическое) связывание. Компилятор смотрит на тип указателя (Animal*), а не на реальный тип объекта, на который он указывает. Поэтому вызывается Animal::speak(), даже если объект на самом деле — Dog или Cat.

Решение: виртуальные функции и позднее связывание

Ключевое слово virtual заставляет компилятор использовать позднее (динамическое) связывание. Это значит, что решение о том, какой метод вызвать, принимается во время выполнения программы на основе реального типа объекта. Вот исправленный код:

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

class Animal {
public:
    virtual void speak() { 
        std::cout << "Some generic animal sound\n"; 
    }
    virtual ~Animal() = default; // Важно: виртуальный деструктор!
};

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

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

int main() {
    std::vector<std::unique_ptr<Animal>> zoo;
    zoo.push_back(std::make_unique<Dog>());
    zoo.push_back(std::make_unique<Cat>());

    for (const auto& animal : zoo) {
        animal->speak();  // Теперь выводит "Woof!" и "Meow!"
    }
    return 0;
}

Как это работает "под капотом"

• Когда компилятор видит virtual, он добавляет в класс скрытый указатель vptr (virtual table pointer).
• Для каждого класса с виртуальными функциями создаётся vtable (виртуальная таблица) — массив указателей на функции.
• При вызове speak() через указатель на базовый класс программа делает два шага:
  1. Берёт vptr из объекта (он указывает на vtable нужного класса — Dog или Cat).
  2. По индексу из vtable получает адрес правильной функции и вызывает её.

Когда использовать virtual?

Виртуальные функции нужны, когда вы работаете с объектами производных классов через указатели или ссылки на базовый класс. Это основа полиморфизма в C++. Без этого вы не сможете единообразно обрабатывать разные типы объектов.

Важно: Всегда объявляйте деструктор базового класса виртуальным (virtual ~Base()), иначе при удалении через указатель на базовый класс не вызовется деструктор производного, что приведёт к утечке памяти.

Сравнение: virtual vs переопределение без virtual

• Без virtual: вызов определяется типом указателя/ссылки. Работает быстро (раннее связывание).
• С virtual: вызов определяется реальным типом объекта. Немного медленнее (позднее связывание через vtable), но даёт гибкость.

В вашем примере без virtual компилятор просто "зашил" вызов Animal::speak() на этапе компиляции. С virtual он добавил механизм, который проверяет реальный тип объекта в рантайме.

template <typename Derived>
class Animal {
public:
    void speak() {
        static_cast<Derived*>(this)->speak_impl();
    }
};

class Dog : public Animal<Dog> {
public:
    void speak_impl() { std::cout << "Woof!\n"; }
};