Как появился ООП и почему он спас программирование

04.02.2025

Почему процедурный подход сломался?

В какой-то момент стало очевидно: программирование в стиле “функция за функцией” больше не работает.

• Код стал слишком сложным. Проекты разрастались, тысячи строк кода путались между собой.

• Работа в команде превратилась в кошмар. Один программист менял кусок кода, а у другого всё ломалось.

• Проекты затягивались. Когда клиент просил добавить что-то новое, код приходилось переделывать с нуля.

• Компьютеры стали личными. Если раньше ПО писали для больших предприятий, то теперь появились ПК, и людям нужны были программы для работы с документами, графикой, базами данных.

Программирование перестало быть просто математикой и превратилось в управление объектами и данными.

ООП – решение проблемы

Где-то в середине 80-х пришло осознание: чтобы программы были удобными и понятными, их нужно строить не вокруг функций, а вокруг объектов – так же, как устроен реальный мир.

Пример:

• В игре есть игрок, враг и оружие.

• У игрока есть здоровье, у врага – атака, у оружия – урон.

• Вместо кучи функций вроде player_attack(), enemy_take_damage() и weapon_damage(), можно просто создать объекты Player, Enemy, Weapon, которые будут сами разбираться, что делать.

Главные идеи ООП

ООП строится на трёх китах:

• Инкапсуляция – каждый объект сам отвечает за свои данные и не даёт их менять кому попало.

• Наследование – можно создавать новые объекты на основе старых, не переписывая код.

• Полиморфизм – один и тот же метод может работать по-разному в зависимости от ситуации.

Инкапсуляция: держим всё в себе

Раньше, если у тебя была переменная player_health, её можно было случайно изменить из любого места в коде. В ООП это запрещено: каждый объект хранит свои данные и защищает их.

class Player {
private:
    int health; // Никто не может изменить здоровье напрямую
public:
    Player(int h) { health = h; }
    void takeDamage(int dmg) { health -= dmg; }
    int getHealth() { return health; }
};

Теперь изменить health можно только через методы класса. Это делает код безопаснее.

Наследование: не повторяемся

Допустим, у нас есть классы Player и Enemy, и у обоих есть здоровье. Вместо копипасты можно создать родительский класс Character, а Player и Enemy просто унаследуют его.

class Character {
protected:
    int health;
public:
    void takeDamage(int dmg) { health -= dmg; }
};

class Player : public Character {
    // Player наследует здоровье и методы из Character
};

Теперь все персонажи автоматически получают логику урона, без дублирования кода.

Полиморфизм: одна команда – разное поведение

Допустим, у нас есть враги разных типов: Orc и Goblin. Оба атакуют, но по-разному. Полиморфизм позволяет вызывать один и тот же метод attack(), но поведение будет разным.

class Enemy {
public:
    virtual void attack() { cout << "Враг атакует!" << endl; }
};

class Orc : public Enemy {
public:
    void attack() override { cout << "Орк наносит мощный удар!" << endl; }
};

class Goblin : public Enemy {
public:
    void attack() override { cout << "Гоблин тыкает ножом!" << endl; }
};

Теперь если вызвать enemy->attack(), программа сама разберётся, что именно делать.

Как ООП изменил разработку

• Вместо функций появились объекты с чёткими ролями.

• Вместо бесконечных if-else – наследование и полиморфизм.

• Вместо хаоса – чистый, модульный код, который легко расширять.

С появлением ООП код стал не просто алгоритмом, а моделью реального мира. Это позволило писать сложные программы, которые живут и взаимодействуют, а не просто выполняют команды сверху вниз.