Что такое наследование в ООП?

Что такое наследование в ООП?

Определение

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

Базовая синтаксис в C++

// Базовый класс (Base Class)
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Some generic sound\n";
    }
    virtual ~Animal() = default;
};

// Производный класс (Derived Class)
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof! Woof!\n";
    }
};

int main() {
    Dog dog;
    dog.makeSound(); // вывод: "Woof! Woof!"
}

Три типа наследования в C++

1. Public наследование (обычный случай)

class Vehicle {
public:
    void start() { /* ... */ }
protected:
    int speed_;
private:
    bool is_running_;
};

class Car : public Vehicle {
public:
    void honk() { /* ... */ }
};

// Доступ из Car:
// - start() → public ✓
// - speed_ → protected ✓
// - is_running_ → private ✗

2. Protected наследование (редко)

class Vehicle { /* ... */ };
class Car : protected Vehicle { 
    // Все public члены Vehicle становятся protected в Car
};

class SportsCar : public Car {
    // Не имеет доступ к методам Vehicle!
};

3. Private наследование (очень редко)

class Vehicle { /* ... */ };
class Car : private Vehicle { 
    // Все члены Vehicle становятся private в Car
    // Это более похоже на composition
};

Иерархия классов

// Базовый класс
class Entity {
public:
    virtual void update() = 0;
    virtual ~Entity() = default;
};

// Промежуточный уровень
class LivingBeing : public Entity {
public:
    virtual void eat() = 0;
    virtual int getAge() const = 0;
};

// Конкретные классы
class Human : public LivingBeing {
public:
    void update() override { /* ... */ }
    void eat() override { /* ... */ }
    int getAge() const override { return age_; }
private:
    int age_;
};

class Dog : public LivingBeing {
public:
    void update() override { /* ... */ }
    void eat() override { /* ... */ }
    int getAge() const override { return age_; }
private:
    int age_;
};

Полиморфизм через наследование

// Работаем через указатель на базовый класс
void processEntity(Entity* entity) {
    entity->update(); // вызовет переопределённый update()
}

int main() {
    Human human;
    Dog dog;
    
    processEntity(&human); // вызовет Human::update()
    processEntity(&dog);   // вызовет Dog::update()
}

Конструкторы и деструкторы

class Base {
public:
    Base(int value) : value_(value) {
        std::cout << "Base constructor\n";
    }
    virtual ~Base() {
        std::cout << "Base destructor\n";
    }
private:
    int value_;
};

class Derived : public Base {
public:
    // Нужно явно вызвать конструктор базового класса
    Derived(int baseVal, int derivedVal) 
        : Base(baseVal), derived_(derivedVal) {
        std::cout << "Derived constructor\n";
    }
    
    virtual ~Derived() {
        std::cout << "Derived destructor\n";
    }
private:
    int derived_;
};

int main() {
    Derived d(10, 20);
    // Вывод:
    // Base constructor
    // Derived constructor
}
// Деструкторы вызываются в обратном порядке:
// Derived destructor
// Base destructor

Виртуальные функции и override

class Shape {
public:
    // virtual указывает, что функция может переопределяться
    virtual double getArea() const = 0;  // pure virtual
    virtual void draw() const { /* default impl */ }
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    // override гарантирует, что переопределяем виртуальную функцию
    double getArea() const override {
        return 3.14159 * radius_ * radius_;
    }
    void draw() const override {
        std::cout << "Drawing circle\n";
    }
private:
    double radius_;
};

Избегаем проблем: правило пяти

class Resource {
public:
    // 1. Конструктор
    Resource() : data_(nullptr) {}
    
    // 2. Копирующий конструктор
    Resource(const Resource& other) 
        : data_(new int(*other.data_)) {}
    
    // 3. Копирующее присваивание
    Resource& operator=(const Resource& other) {
        if (this != &other) {
            delete data_;
            data_ = new int(*other.data_);
        }
        return *this;
    }
    
    // 4. Move конструктор
    Resource(Resource&& other) noexcept 
        : data_(other.data_) {
        other.data_ = nullptr;
    }
    
    // 5. Move присваивание
    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete data_;
            data_ = other.data_;
            other.data_ = nullptr;
        }
        return *this;
    }
    
    ~Resource() { delete data_; }
private:
    int* data_;
};

Множественное наследование (осторожно!)

class Flyable {
public:
    virtual void fly() = 0;
};

class Swimmable {
public:
    virtual void swim() = 0;
};

// Duck может и летать, и плавать
class Duck : public Flyable, public Swimmable {
public:
    void fly() override { /* ... */ }
    void swim() override { /* ... */ }
};

⚠️ Проблема — Diamond Problem:

class Animal { public: virtual void eat() = 0; };
class Bird : public Animal { /* ... */ };
class Fish : public Animal { /* ... */ };
class Duck : public Bird, public Fish { }; // ⚠️ Animal присутствует дважды!

// Решение: виртуальное наследование
class Bird : virtual public Animal { /* ... */ };
class Fish : virtual public Animal { /* ... */ };

Composition vs Inheritance

// ❌ Неправильно: наследование для возможности
class Car : public Engine { 
    // Engine не нужно наследовать
};

// ✅ Правильно: composition
class Car {
private:
    Engine engine_;  // Car СОДЕРЖИТ Engine
};

// ✅ Правильно: наследование для is-a отношения
class ElectricCar : public Car {
    // ElectricCar IS-A Car
};

Best Practices

1. Используйте public наследование только для IS-A отношений
2. Делайте деструкторы базовых классов виртуальными
3. Предпочитайте composition наследованию для реиспользования функциональности
4. Используйте override для явного указания переопределения
5. Избегайте множественного наследования, если возможно
6. Используйте abstract базовые классы (pure virtual методы)

Вывод

Наследование — это мощный инструмент для построения иерархий типов и переиспользования кода в C++. Однако оно требует понимания деталей (виртуальные функции, деструкторы, порядок инициализации) и осторожного использования. В современном C++ часто предпочитают композицию наследованию, так как это снижает связанность кода и облегчает тестирование.