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

Что такое виртуальные функции и как они решают вашу проблему

Ваш пример отлично демонстрирует необходимость виртуальных функций. Проблема в том, что по умолчанию C++ использует раннее связывание (early binding) — компилятор определяет, какой метод вызвать, на основе типа указателя, а не фактического типа объекта. Когда вы пишете Animal* ptr = new Dog(), компилятор видит указатель на Animal и вызывает Animal::speak(), игнорируя то, что объект на самом деле — Dog.

Виртуальные функции включают позднее связывание (late binding) или динамический полиморфизм. Решение простое — добавьте ключевое слово virtual перед методом в базовом классе:

class Animal {
public:
    virtual void speak() { cout << "Some animal sound\n"; }
};

class Dog : public Animal {
public:
    void speak() override { cout << "Woof!\n"; } // override — опционально, но рекомендуется
};

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

Теперь код будет работать как ожидается:

Animal* ptr1 = new Dog();
Animal* ptr2 = new Cat();
ptr1->speak(); // Woof!
ptr2->speak(); // Meow!
delete ptr1;
delete ptr2;

Как это работает под капотом: виртуальная таблица (vtable)

Когда вы объявляете хотя бы одну виртуальную функцию в классе, компилятор создаёт для него виртуальную таблицу (vtable) — массив указателей на функции. Каждый объект такого класса получает скрытый указатель vptr, который ссылается на vtable своего класса.

• Animal::vtable содержит указатель на Animal::speak().
• Dog::vtable содержит указатель на Dog::speak().
• Cat::vtable содержит указатель на Cat::speak().

Когда вы вызываете ptr->speak(), программа:

1. Берёт vptr из объекта (по адресу ptr).
2. Переходит по этому указателю в vtable класса.
3. Находит нужную функцию (например, Dog::speak()) и вызывает её.

Это происходит во время выполнения (runtime), поэтому называется динамическим полиморфизмом.

Зачем это нужно?

Виртуальные функции позволяют писать код, который работает с любым производным классом через указатель на базовый. Это основа полиморфизма — одного из ключевых принципов ООП. Примеры использования:

• Массивы разнотипных объектов: vector<Animal*> zoo; — можно хранить и собак, и кошек.
• Функции, работающие с любым наследником:

void makeSound(Animal* animal) {
    animal->speak(); // Вызовется правильный метод
}

int main() {
    makeSound(new Dog());  // Woof!
    makeSound(new Cat());  // Meow!
}

• Паттерны проектирования: Стратегия, Фабрика, Команда и другие.

Важные моменты

• Виртуальный деструктор: Если класс имеет виртуальные функции, деструктор тоже должен быть виртуальным, иначе при удалении через указатель на базовый класс не вызовется деструктор производного:

class Animal {
public:
    virtual ~Animal() {} // Обязательно!
    virtual void speak() = 0; // Чисто виртуальная функция (см. ниже)
};

• Чисто виртуальные функции: virtual void speak() = 0; — делает класс абстрактным. Нельзя создать объект такого класса, только наследников. Идеально для интерфейсов.
• Ключевое слово override: (C++11) помогает компилятору проверить, что вы действительно переопределяете виртуальную функцию, а не создаёте новую с другим именем.
• Производительность: Виртуальные функции имеют небольшой оверхед (косвенный вызов через vtable), но в 99% случаев это незаметно. Не оптимизируйте преждевременно.

Таким образом, виртуальные функции — это механизм, который позволяет C++ поддерживать полиморфизм во время выполнения, давая возможность писать гибкий и расширяемый код.

template <typename T>
void makeSound(T& animal) {
    animal.speak(); // Вызовется метод конкретного типа
}

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

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

int main() {
    Dog dog;
    Cat cat;
    makeSound(dog); // Woof!
    makeSound(cat); // Meow!
}