В чем разница между virtual и override?

Разница между virtual и override

Это два разных концепта в полиморфизме C++, и их часто путают. Они работают на разных уровнях: virtual определяет поведение, а override — обеспечивает безопасность.

virtual: определение виртуального метода

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

class Animal {
public:
    virtual void sound() {  // Виртуальный метод
        std::cout << "Some generic sound" << std::endl;
    }
    
    virtual ~Animal() {}  // Виртуальный деструктор (обязателен!)
};

class Dog : public Animal {
public:
    void sound() override {  // Переопределяем в производном классе
        std::cout << "Woof!" << std::endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->sound();  // Вывет Dog::sound(), не Animal::sound()
    delete animal;
    return 0;
}

Вывод:

Woof!

override: гарантия правильного переопределения

override (C++11) — это не ключевое слово в истинном смысле, а контекстное ключевое слово. Оно указывает компилятору: «Проверь, что я переопределяю виртуальный метод из базового класса». Если метод не существует или сигнатура не совпадает, компилятор выдаст ошибку.

class Bird {
public:
    virtual void fly() {
        std::cout << "Flying..." << std::endl;
    }
};

class Sparrow : public Bird {
public:
    // Ошибка компиляции: метод fly() не существует в Bird
    void fly_away() override {
        std::cout << "Flying away" << std::endl;
    }
};

Ошибка компилятора:

error: 'fly_away' marked 'override' but does not override

Практический пример различия

class Base {
public:
    virtual void process(int x) {}
    virtual ~Base() {}
};

class Derived1 : public Base {
public:
    // БЕЗ override — ОПАСНО!
    // Если сигнатура не совпадает, это новый метод, не переопределение
    void process(double x) {  // Совпадает ли с Base::process(int)? НЕТ!
        std::cout << "Processing double" << std::endl;
    }
};

class Derived2 : public Base {
public:
    // С override — БЕЗОПАСНО!
    void process(double x) override {  // ОШИБКА КОМПИЛЯЦИИ!
        // Компилятор скажет, что это не переопределение
    }
};

V-Table и виртуальные функции

Когда вы объявляете метод как virtual, компилятор:

1. Создаёт таблицу виртуальных функций (v-table) для класса
2. Каждый объект хранит указатель на v-table
3. При вызове виртуального метода используется этот указатель для поиска правильной реализации

class Shape {
public:
    virtual void draw() = 0;  // Чистая виртуальная функция
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override {  // Обязателен override для чистых виртуальных
        std::cout << "Drawing circle" << std::endl;
    }
};

int main() {
    // Shape s;  // ОШИБКА: Shape — абстрактный класс
    
    Circle c;
    Shape* shape = &c;  // Указатель на базовый класс
    shape->draw();      // Вызывает Circle::draw() через v-table
    
    return 0;
}

Правила использования override

Когда ОБЯЗАТЕЛЬНО использовать override

1. Переопределение в производных классах:

class Base {
public:
    virtual void method() {}
};

class Derived : public Base {
public:
    void method() override {  // ПРАВИЛЬНО
        // Компилятор проверит сигнатуру
    }
};

2. Абстрактные методы:

class Interface {
public:
    virtual void doSomething() = 0;  // Чистая виртуальная
    virtual ~Interface() {}
};

class Implementation : public Interface {
public:
    void doSomething() override {  // ПРАВИЛЬНО и ОБЯЗАТЕЛЬНО
        std::cout << "Implementation" << std::endl;
    }
};

Когда НЕ нужен override

1. В самом базовом классе:

class Base {
public:
    virtual void method() {  // override не нужен, это первое определение
        std::cout << "Base implementation" << std::endl;
    }
};

Практические ошибки

Ошибка 1: Разная сигнатура метода

class Base {
public:
    virtual void process(const std::string& str) {}
    virtual ~Base() {}
};

class Derived : public Base {
public:
    // БЕЗ override:
    void process(std::string str) {  // Копия, не ссылка!
        // Это не переопределение — создан новый метод!
    }
    
    // С override:
    void process(std::string str) override {  // ОШИБКА КОМПИЛЯЦИИ
        // Компилятор скажет, что это не переопределение
    }
};

Ошибка 2: Забыли virtual

class Base {
public:
    void process() {  // НЕ virtual!
        std::cout << "Base" << std::endl;
    }
};

class Derived : public Base {
public:
    void process() override {  // ОШИБКА: нет virtual в Base
        std::cout << "Derived" << std::endl;
    }
};

int main() {
    Base* ptr = new Derived();
    ptr->process();  // Вывет Base::process(), не Derived::process()
    delete ptr;
}

Вывод: Base (неожиданно!)

Best Practices

1. ВСЕГДА используйте override в производных классах:

// ХОРОШО
class Derived : public Base {
public:
    void method() override {}  // override помогает ловить ошибки
};

2. Делайте деструкторы виртуальными в базовых классах:

class Base {
public:
    virtual ~Base() {}  // КРИТИЧНО!
};

3. Используйте final для запрета переопределения (C++11):

class Base {
public:
    virtual void method() final {  // Нельзя переопределить
        std::cout << "Final implementation" << std::endl;
    }
};

class Derived : public Base {
public:
    void method() override {}  // ОШИБКА КОМПИЛЯЦИИ
};

Резюме

• virtual: Говорит компилятору, что метод может быть переопределён. Включает динамический полиморфизм.
• override: Просит компилятор проверить, что я действительно переопределяю виртуальный метод. Предотвращает ошибки.
• Всегда используйте override в современном C++11+ коде — это спасает от неловких ошибок при рефакторинге.