В чем разница между переопределением и перегрузкой?

В чем разница между переопределением и перегрузкой?

Это два фундаментальных механизма в C++, которые часто путают, но они решают разные задачи.

Быстрое сравнение

Переопределение (Override)

Переопределение — это переписывание метода базового класса в производном классе.

class Animal {
public:
    virtual void makeSound() { // базовая реализация
        std::cout << "Some generic sound\n";
    }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void makeSound() override { // переопределяем метод
        std::cout << "Woof! Woof!\n";
    }
};

class Cat : public Animal {
public:
    void makeSound() override { // переопределяем метод
        std::cout << "Meow!\n";
    }
};

int main() {
    Dog dog;
    Cat cat;
    
    dog.makeSound(); // Woof! Woof!
    cat.makeSound(); // Meow!
    
    // Полиморфизм: один тип, разное поведение
    Animal& animal1 = dog;
    Animal& animal2 = cat;
    
    animal1.makeSound(); // Woof! Woof! (вызовет Dog::makeSound)
    animal2.makeSound(); // Meow! (вызовет Cat::makeSound)
}

Ключные моменты переопределения:

1. Сигнатура ДОЛЖНА совпадать

class Base {
public:
    virtual void process(int value) { /* ... */ }
};

class Derived : public Base {
public:
    void process(int value) override { // ✓ правильно: сигнатура совпадает
        Base::process(value); // можно вызвать базовую версию
        std::cout << "Derived processing\n";
    }
};

1. Должна быть virtual в базовом классе

class Base {
public:
    void process() { } // ❌ не virtual!
};

class Derived : public Base {
public:
    void process() override { } // ❌ переопределяет, но не полиморфно!
};

int main() {
    Base* base = new Derived();
    base->process(); // вызовет Base::process(), не Derived::process()!
}

1. override помогает поймать ошибки

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

class Derived : public Base {
public:
    void process(double value) override { } // ❌ компилятор ошибка!
    // сигнатура не совпадает
};

1. Динамическое связывание (dynamic binding)

void callProcess(Animal* animal) {
    animal->makeSound(); // КАКОЙ метод вызвать?
    // Решается во время выполнения в зависимости от типа animal
    // Если Dog* → вызовет Dog::makeSound()
    // Если Cat* → вызовет Cat::makeSound()
}

int main() {
    Dog dog;
    callProcess(&dog); // решение принимается в runtime!
}

Перегрузка (Overload)

Перегрузка — это создание нескольких функций/методов с одинаковым именем, но разными параметрами.

class Calculator {
public:
    // Перегрузка: разные типы параметров
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

int main() {
    Calculator calc;
    
    std::cout << calc.add(2, 3);          // вызовет int add(int, int)
    std::cout << calc.add(2.5, 3.5);      // вызовет double add(double, double)
    std::cout << calc.add(2, 3, 4);       // вызовет int add(int, int, int)
}

Ключные моменты перегрузки:

1. Решение принимается во время компиляции (compile-time)

class Processor {
public:
    void process(int x) { std::cout << "Processing int\n"; }
    void process(double x) { std::cout << "Processing double\n"; }
};

int main() {
    Processor p;
    
    int i = 42;
    double d = 3.14;
    
    p.process(i); // компилятор ЗНАЕТ во время компиляции, какую версию вызвать
    p.process(d); // решение уже принято, не будет runtime проверки
}

1. Не нужна virtual

class Math {
public:
    int square(int x) { return x * x; }
    double square(double x) { return x * x; }
    // virtual не нужна! Решение во время компиляции
};

1. Может быть в одном классе

class StringUtils {
public:
    std::string concat(const std::string& a, const std::string& b) { /* ... */ }
    std::string concat(const std::string& a, const std::string& b, const std::string& c) { /* ... */ }
    std::string concat(const char* a, const char* b) { /* ... */ }
    // все в одном классе
};

1. Правила разрешения (resolution rules)

Компилятор выбирает перегрузку по:

• Типам параметров
• Количеству параметров
• Cv-квалификаторам (const/volatile)
• Ссылкам (& и &&)

class Handler {
public:
    void handle(int& x) { std::cout << "handle(int&)\n"; }
    void handle(const int& x) { std::cout << "handle(const int&)\n"; }
    void handle(int&& x) { std::cout << "handle(int&&)\n"; }
};

int main() {
    Handler h;
    
    int x = 42;
    h.handle(x);           // handle(int&)
    h.handle(std::move(x)); // handle(int&&)
    
    const int cx = 42;
    h.handle(cx);          // handle(const int&)
}

Сравнение на примере

// Допустим, нужна функция для вывода информации

// ❌ БЕЗ перегрузки и переопределения (неудобно)
class Logger {
public:
    void logInt(int value) { std::cout << value; }
    void logDouble(double value) { std::cout << value; }
    void logString(const std::string& value) { std::cout << value; }
};

// ✓ С перегрузкой (удобнее)
class Logger {
public:
    void log(int value) { std::cout << value; }
    void log(double value) { std::cout << value; }
    void log(const std::string& value) { std::cout << value; }
};

Logger logger;
logger.log(42);          // log(int)
logger.log(3.14);        // log(double)
logger.log("hello");    // log(const std::string&)

Переопределение + перегрузка вместе

class Base {
public:
    virtual void process(int x) { std::cout << "Base::process(int)\n"; }
    virtual void process(double x) { std::cout << "Base::process(double)\n"; }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void process(int x) override { std::cout << "Derived::process(int)\n"; }
    void process(double x) override { std::cout << "Derived::process(double)\n"; }
};

int main() {
    Derived d;
    
    d.process(42);      // Derived::process(int) — перегрузка выбрала версию с int
    d.process(3.14);    // Derived::process(double) — перегрузка выбрала версию с double
    
    Base* b = &d;
    b->process(42);     // Derived::process(int) — переопределение выбрало Derived версию
    b->process(3.14);   // Derived::process(double) — переопределение выбрало Derived версию
}

Опасность: скрытие методов (Name Hiding)

class Base {
public:
    virtual void work(int x) { std::cout << "Base::work(int)\n"; }
};

class Derived : public Base {
public:
    void work(double x) { std::cout << "Derived::work(double)\n"; } // ⚠️ Опасно!
};

int main() {
    Derived d;
    d.work(5);          // Derived::work(double) — неожиданно!
    // Вместо Base::work(int), используется Derived::work(double)
    d.work(3.14);       // Derived::work(double)
    
    // Решение: явно использовать using
}

Исправление с using:

class Derived : public Base {
public:
    using Base::work;   // сделать видимым Base::work
    void work(double x) override { std::cout << "Derived::work(double)\n"; }
};

int main() {
    Derived d;
    d.work(5);          // Base::work(int) — правильно!
    d.work(3.14);       // Derived::work(double)
}

Практические примеры

Перегрузка: различные типы параметров

class DataProcessor {
public:
    void process(int x) { /* ... */ }
    void process(const std::string& s) { /* ... */ }
    void process(const std::vector<int>& v) { /* ... */ }
    void process(const std::map<std::string, int>& m) { /* ... */ }
};

DataProcessor processor;
processor.process(42);
processor.process("hello");
processor.process(std::vector<int>{1, 2, 3});
processor.process(std::map<std::string, int>{{"a", 1}});

Переопределение: полиморфизм

class Storage {
public:
    virtual void save(const std::string& data) = 0;
    virtual std::string load() = 0;
    virtual ~Storage() = default;
};

class FileStorage : public Storage {
public:
    void save(const std::string& data) override { /* сохранить в файл */ }
    std::string load() override { /* загрузить из файла */ }
};

class DatabaseStorage : public Storage {
public:
    void save(const std::string& data) override { /* сохранить в БД */ }
    std::string load() override { /* загрузить из БД */ }
};

Вывод

Переопределение (Override):

• Дочерний класс переписывает метод родителя
• Одинаковая сигнатура
• Требует virtual
• Полиморфизм: динамическое связывание (runtime)

Перегрузка (Overload):

• Одно имя, разные сигнатуры
• Один класс или область видимости
• Не требует virtual
• Статическое связывание (compile-time)

Вместе они создают мощную систему для:

• Удобных интерфейсов (перегрузка)
• Гибких иерархий классов (переопределение)
• Правильного разделения ответственности