Какую проблему решает override?

Проблема, которую решает override в C++

Ключевое слово override в C++11+ решает критическую проблему в объектно-ориентированном программировании — обеспечение безопасности при переопределении виртуальных методов в иерархиях классов. Это простое слово предотвращает множество трудноуловимых багов.

Основная проблема (без override)

// Базовый класс
class Shape {
public:
    virtual ~Shape() = default;
    virtual void draw() const {
        std::cout << "Drawing shape\n";
    }
    
    virtual double area() const = 0;
};

// Подкласс: попытка переопределить методы
class Circle : public Shape {
public:
    // Проблема 1: опечатка в имени метода
    void draw_() const {
        std::cout << "Drawing circle\n";
    }
    
    // Проблема 2: неправильная сигнатура
    void area() {
        return 3.14;
    }
};

int main() {
    Shape* shape = new Circle();
    shape->draw();  // Выведет "Drawing shape"!
    delete shape;
    return 0;
}

Видите проблему? Компилятор не может сказать вам, что вы ошиблись! Код скомпилируется и запустится, но поведение будет неправильным.

Решение: override

class Circle : public Shape {
public:
    // Теперь компилятор ДОЛЖЕН проверить!
    void draw() const override {
        std::cout << "Drawing circle\n";
    }
    
    double area() const override {
        return 3.14159 * radius * radius;
    }

private:
    double radius = 1.0;
};

С override все проблемы выявляются на этапе компиляции:

class Circle : public Shape {
public:
    void draw_() const override {  // ОШИБКА КОМПИЛЯТОРА
        // error: does not override
    }
    
    void area() override {  // ОШИБКА КОМПИЛЯТОРА
        // error: const qualifier отличается
    }
};

Чем именно помогает override

1. Проверка наличия виртуального метода в базовом классе

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

class Derived : public Base {
public:
    void execute() override {}  // OK: существует в Base
    void perform() override {}  // ОШИБКА! No virtual function
};

2. Проверка сигнатуры метода (параметры, const, reference qualifiers)

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

class Derived : public Base {
public:
    void process(int x) const override {}     // OK: полное совпадение
    void process(double x) const override {}  // ОШИБКА: другой тип
    void process(int x) override {}           // ОШИБКА: нет const
};

3. Проверка типа возврата (covariant returns)

class Animal {
public:
    virtual ~Animal() = default;
    virtual Animal* clone() { return new Animal(*this); }
};

class Dog : public Animal {
public:
    Dog* clone() override {  // OK: covariant return
        return new Dog(*this);
    }
};

Дополнительные защиты: final

final предотвращает дальнейшее переопределение:

class Base {
public:
    virtual void method1() {}
    virtual void method2() final {}  // Нельзя переопределять
};

class Derived : public Base {
public:
    void method1() override {}   // OK
    void method2() override {}   // ОШИБКА: method2 marked final
};

class DoNotInheritFromMe final {  // Нельзя наследоваться
};

class Error : public DoNotInheritFromMe {};  // ОШИБКА

Практические примеры из real-world кода

Хорошо:

class DatabaseConnection {
public:
    virtual ~DatabaseConnection() = default;
    virtual bool connect(const std::string& url) = 0;
    virtual void disconnect() = 0;
    virtual bool execute(const std::string& query) = 0;
};

class PostgresConnection : public DatabaseConnection {
public:
    bool connect(const std::string& url) override {
        return true;
    }
    
    void disconnect() override {
        // закрытие соединения
    }
    
    bool execute(const std::string& query) override {
        return true;
    }
};

Плохо (старый стиль C++98):

class MySQLConnection : public DatabaseConnection {
public:
    bool connect(const std::string& url) {  // БЕЗ override!
        // Если базовый класс изменится, это сломается молча
        return true;
    }
};

Modern C++ Best Practices

Всегда используй override для виртуальных функций:

class CacheStrategy {
public:
    virtual ~CacheStrategy() = default;
    virtual void evict() = 0;
    virtual void put(const std::string& key, const std::string& value) = 0;
};

class LRUCache : public CacheStrategy {
public:
    ~LRUCache() override = default;
    void evict() override { }
    void put(const std::string& key, const std::string& value) override {}
};

Используй final для стабилизации API:

class CoreAlgorithm {
public:
    virtual ~CoreAlgorithm() = default;
    virtual void validateInput() final {}  // Критичен, не переопределяй
    virtual void process() {}              // Можно переопределять
};

Выводы

override решает:

• Опечатки в названиях методов
• Несовпадение сигнатур (параметры, const)
• Случайное удаление методов из базового класса
• Нарушение контракта наследования

Хороший стиль (С++11 и выше):

• Всегда пиши override при переопределении
• Добавляй final для методов/классов, которые нельзя изменять
• Используй virtual в базовом классе, override в производных

Это простое слово делает код на порядок более безопасным и маинтейнабл.