Конструктори, деструктори та порядок ініціалізації в ієрархіях

Від простих класів до ієрархій: нова складність

У попередній статті ми дослідили наслідування як відношення «є різновидом» (is-a) та побудували перші ієрархії класів — Person → Student, Employee. Ми навчилися створювати похідні класи за допомогою синтаксису class Derived : public Base та розуміти, що похідний об'єкт фізично містить у собі під'об'єкт базового класу.

Проте ми не розглянули фундаментальне питання: що відбувається під час створення та знищення об'єктів у ієрархіях? Якщо похідний клас містить у собі базовий як частину, то хто відповідає за ініціалізацію полів базового класу? У якому порядку викликаються конструктори та деструктори? Чи може похідний клас безпосередньо ініціалізувати поля предка?

Ці питання не виникали при роботі з автономними класами, але у світі наслідування вони стають критично важливими. Без розуміння життєвого циклу об'єктів у ієрархіях ми не зможемо коректно проєктувати конструктори, керувати ресурсами та уникати тонких помилок ініціалізації.

Фізична структура похідного об'єкта

Перш ніж аналізувати життєвий цикл, нагадаємо фундаментальну властивість наслідування: похідний об'єкт не копіює члени базового класу — він містить у собі під'об'єкт базового класу як фізичну частину.

Розглянемо просту ієрархію:

class Person
{
private:
    string name;
    int age;

public:
    Person(string n, int a) : name(n), age(a) {}
    
    string getName() const { return name; }
    int getAge() const { return age; }
};

class Student : public Person
{
private:
    string studentId;
    double gpa;

public:
    Student(string n, int a, string id, double g)
        : Person(n, a), studentId(id), gpa(g) 
    {}
    
    string getStudentId() const { return studentId; }
    double getGpa() const { return gpa; }
};

Коли ми створюємо об'єкт Student, компілятор виділяє в пам'яті достатньо місця для усіх полів: name та age (з Person) + studentId та gpa (власні поля Student). Концептуально об'єкт Student складається з двох логічних частин:

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam classAttributeIconSize 0

rectangle "Об'єкт класу Student\nв пам'яті" as StudentObj #F1F5F9 {
    rectangle "Частина Person (базовий клас)" as PersonPart #DBEAFE {
        class " " as PersonData {
            - name: string
            - age: int
        }
    }
    
    rectangle "Частина Student (похідний клас)" as StudentPart #DCFCE7 {
        class " " as StudentData {
            - studentId: string
            - gpa: double
        }
    }
}

note right of StudentObj #FEF3C7
  Під'об'єкт Person завжди
  розміщується **на початку**
  пам'яті об'єкта Student.
end note

@enduml

Чому фундамент будують раніше за стіни

Логіка поетапної ініціалізації ієрархій спирається на фундаментальний принцип: базовий клас повинен бути повністю сконструйований раніше похідного. Цей принцип не є довільним рішенням розробників C++ — він диктується реальними потребами безпеки та коректності.

Розглянемо причини, чому конструктор базового класу завжди викликається першим:

::

Правило просте: фундамент будують раніше за стіни. Базовий клас — це «фундамент» об'єкта, а похідний — «стіни», які на ньому зведені. Спроба побудувати стіни на неготовому фундаменті завершиться катастрофою.

Порядок виклику конструкторів: демонстрація

Продемонструємо порядок виклику конструкторів на простому прикладі. Додамо виведення повідомлень у конструктори, щоб побачити послідовність їхнього виконання:

#include <iostream>

using namespace std;

class Person
{
private:
    string name;
    int age;

public:
    Person(string n, int a) : name(n), age(a)
    {
        cout << "  Конструктор Person: " << name << ", вік " << age << "\n";
    }
    
    string getName() const { return name; }
    int getAge() const { return age; }
};

class Student : public Person
{
private:
    string studentId;

public:
    Student(string n, int a, string id)
        : Person(n, a), studentId(id)
    {
        cout << "  Конструктор Student: ID " << studentId << "\n";
    }
    
    string getStudentId() const { return studentId; }
};

int main()
{
    cout << "Створюємо автономний об'єкт Person:\n";
    Person person("Олена Петрова", 42);
    
    cout << "\nСтворюємо об'єкт Student:\n";
    Student student("Іван Сидоренко", 20, "CS-2024-0517");
    
    return 0;
}

Результат підтверджує послідовність:

1. Створення Person person(...): викликається лише конструктор Person — це автономний клас без предків.
2. Створення Student student(...): спочатку викликається конструктор Person (для ініціалізації частини Person об'єкта student), а потім — конструктор Student (для ініціалізації власних полів Student).

Детальна послідовність створення об'єкта похідного класу

Розглянемо покроково, що відбувається під час виконання рядка Student student("Іван Сидоренко", 20, "CS-2024-0517");:

Student(string n, int a, string id)
    : Person(n, a), studentId(id)  // ← Список ініціалізації

{
    cout << "  Конструктор Student: ID " << studentId << "\n";
}

Student(string n, int a, string id)
    : studentId(id), Person(n, a)  // Person записаний другим

Неявний виклик конструктора за замовчуванням базового класу

У попередньому прикладі ми явно викликали конструктор Person(string, int) через список ініціалізації:

Student(string n, int a, string id)
    : Person(n, a), studentId(id)  // Явний виклик Person(string, int)

Але що станеться, якщо не вказати виклик конструктора базового класу? Компілятор не може залишити базову частину об'єкта неініціалізованою — це порушило б гарантії C++. Тому компілятор автоматично викликає конструктор за замовчуванням базового класу.

Розглянемо приклад:

class Person
{
private:
    string name;
    int age;

public:
    // Конструктор за замовчуванням
    Person() : name("Невідомо"), age(0)
    {
        cout << "  Person(): використано значення за замовчуванням\n";
    }
    
    Person(string n, int a) : name(n), age(a)
    {
        cout << "  Person(string, int): " << name << ", вік " << age << "\n";
    }
    
    string getName() const { return name; }
    int getAge() const { return age; }
};

class Student : public Person
{
private:
    string studentId;

public:
    // Не вказуємо виклик конструктора Person!
    Student(string id) : studentId(id)
    {
        cout << "  Student(string): ID " << studentId << "\n";
    }
};

int main()
{
    Student student("CS-2024-1001");
    
    cout << "\nДані студента:\n";
    cout << "Ім'я: " << student.getName() << "\n";
    cout << "Вік: " << student.getAge() << "\n";
    
    return 0;
}

Оскільки конструктор Student(string id) не містить явного виклику конструктора Person, компілятор автоматично вставляє виклик Person() — конструктора за замовчуванням. Результат: частина Person об'єкта student ініціалізована значеннями «Невідомо» та 0.

Проблема: відсутність конструктора за замовчуванням

А що станеться, якщо в базовому класі немає конструктора за замовчуванням, а похідний клас не викликає жодний конструктор базового класу явно?

Розглянемо приклад:

class Person
{
private:
    string name;
    int age;

public:
    // Є лише параметризований конструктор, немає конструктора за замовчуванням
    Person(string n, int a) : name(n), age(a)
    {
        cout << "  Person(string, int): " << name << "\n";
    }
    
    string getName() const { return name; }
};

class Student : public Person
{
private:
    string studentId;

public:
    // Не вказуємо виклик Person(string, int)
    Student(string id) : studentId(id)  // ❌ Помилка компіляції!
    {
        cout << "  Student(string): ID " << studentId << "\n";
    }
};

Спроба скомпілювати цей код призведе до помилки:

Компілятор намагається неявно викликати Person() (конструктор за замовчуванням), але такого конструктора не існує. Є лише Person(string, int), який вимагає два аргументи.

Виправлення: завжди явно викликайте потрібний конструктор базового класу:

class Student : public Person
{
private:
    string studentId;

public:
    Student(string id, string name, int age)
        : Person(name, age), studentId(id)  // ✅ Явний виклик Person(string, int)
    {
        cout << "  Student: ID " << studentId << "\n";
    }
};

Тепер компіляція успішна:

Student student("CS-2024-1001", "Марія Коваленко", 19);

Ініціалізація полів базового класу: чому не можна це робити безпосередньо

Початківці часто намагаються ініціалізувати успадковані поля базового класу безпосередньо у списку ініціалізації похідного конструктора:

class Student : public Person
{
private:
    string studentId;

public:
    Student(string n, int a, string id)
        : name(n), age(a), studentId(id)  // ❌ Помилка компіляції!
    {
    }
};

Компілятор відхилить цей код із помилкою:

C++ категорично забороняє похідному класу ініціалізувати успадковані поля в своєму списку ініціалізації. Чому? З кількох причин:

::

Правильний підхід: завжди викликати конструктор базового класу та передавати йому параметри:

Student(string n, int a, string id)
    : Person(n, a), studentId(id)  // ✅ Базовий клас сам ініціалізує свої поля

Альтернативний (але не рекомендований) підхід: присвоєння в тілі конструктора

Деякі початківці намагаються обійти обмеження списку ініціалізації, присвоюючи значення успадкованим полям у тілі конструктора похідного класу:

class Person
{
protected:  // Змінили на protected, щоб похідний клас мав доступ
    string name;
    int age;

public:
    Person() : name(""), age(0) {}  // Потрібен конструктор за замовчуванням
    
    string getName() const { return name; }
    int getAge() const { return age; }
};

class Student : public Person
{
private:
    string studentId;

public:
    Student(string n, int a, string id) : studentId(id)
    {
        // Присвоєння в тілі конструктора
        name = n;
        age = a;
    }
};

Цей код скомпілюється та працюватиме, але він має кілька серйозних недоліків:

::

Висновок: завжди передавайте параметри конструктору базового класу через список ініціалізації. Присвоєння в тілі конструктора — це анти-патерн, який призводить до неефективності та тонких помилок.

Багаторівневе наслідування: ланцюжок викликів конструкторів

До цього моменту ми розглядали прості ієрархії з двома рівнями: Person → Student. Але реальні системи часто будують багаторівневі ієрархії (multi-level inheritance), де один клас успадковує від іншого, який, у свою чергу, успадковує від третього.

Розглянемо триланкову ієрархію:

class Person
{
protected:
    string name;

public:
    Person(string n) : name(n)
    {
        cout << "  → Конструктор Person: " << name << "\n";
    }
};

class Student : public Person
{
protected:
    string studentId;

public:
    Student(string n, string id) : Person(n), studentId(id)
    {
        cout << "  → Конструктор Student: ID " << studentId << "\n";
    }
};

class GraduateStudent : public Student
{
private:
    string thesisTopic;

public:
    GraduateStudent(string n, string id, string topic)
        : Student(n, id), thesisTopic(topic)
    {
        cout << "  → Конструктор GraduateStudent: тема \"" << thesisTopic << "\"\n";
    }
};

int main()
{
    cout << "Створюємо аспіранта:\n";
    GraduateStudent grad("Олександр Мельник", "PhD-2025-042", 
                         "Оптимізація алгоритмів машинного навчання");
    
    return 0;
}

Порядок виклику конструкторів у багаторівневій ієрархії: від найвищого предка до найнижчого нащадка, як будівництво будинку поверх за поверхом:

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
autonumber

participant "main()" as Main #F1F5F9
participant "GraduateStudent\nконструктор" as Grad #DCFCE7
participant "Student\nконструктор" as Stud #DBEAFE
participant "Person\nконструктор" as Pers #FEF3C7

Main -> Grad : створити об'єкт grad
activate Grad

Grad -> Stud : викликати Student(n, id)
activate Stud

Stud -> Pers : викликати Person(n)
activate Pers

Pers -> Pers : ініціалізувати name
Pers -> Pers : вивести повідомлення
deactivate Pers

Stud -> Stud : ініціалізувати studentId
Stud -> Stud : вивести повідомлення
deactivate Stud

Grad -> Grad : ініціалізувати thesisTopic
Grad -> Grad : вивести повідомлення
deactivate Grad

Main <-- Grad : об'єкт grad готовий

@enduml

Правило безпосереднього батька: чому не можна «перестрибнути» рівень

Початківці іноді намагаються оптимізувати код, напряму викликаючи конструктор «віддаленого предка»:

class GraduateStudent : public Student
{
public:
    GraduateStudent(string n, string id, string topic)
        : Person(n), thesisTopic(topic)  // ❌ Спроба викликати Person напряму
    {
    }
};

Цей код не скомпілюється:

C++ забороняє похідному класу викликати конструктори класів, від яких він не успадковує безпосередньо. GraduateStudent успадковує від Student, а не від Person. Тому GraduateStudent може викликати лише конструктори Student.

Чому це обмеження існує?

Правильний підхід: кожен клас передає параметри своєму безпосередньому батьку, а той — своєму батьку, і так далі:

GraduateStudent(string n, string id, string topic)
    : Student(n, id), thesisTopic(topic)  // ✅ Викликаємо лише безпосереднього батька

Клас Student сам вирішить, як передати параметри конструктору Person.

Порядок деструкторів: дзеркальне відображення конструкторів

Тепер розглянемо знищення об'єктів у ієрархіях. Коли об'єкт похідного класу виходить зі scope або видаляється через delete, деструктори викликаються у зворотному порядку відносно конструкторів: від нащадка до предка.

Продемонструємо це на попередньому прикладі, додавши деструктори:

#include <iostream>

using namespace std;

class Person
{
protected:
    string name;

public:
    Person(string n) : name(n)
    {
        cout << "  → Конструктор Person: " << name << "\n";
    }
    
    ~Person()
    {
        cout << "  ← Деструктор Person: " << name << "\n";
    }
};

class Student : public Person
{
protected:
    string studentId;

public:
    Student(string n, string id) : Person(n), studentId(id)
    {
        cout << "  → Конструктор Student: ID " << studentId << "\n";
    }
    
    ~Student()
    {
        cout << "  ← Деструктор Student: ID " << studentId << "\n";
    }
};

class GraduateStudent : public Student
{
private:
    string thesisTopic;

public:
    GraduateStudent(string n, string id, string topic)
        : Student(n, id), thesisTopic(topic)
    {
        cout << "  → Конструктор GraduateStudent: \"" << thesisTopic << "\"\n";
    }
    
    ~GraduateStudent()
    {
        cout << "  ← Деструктор GraduateStudent: \"" << thesisTopic << "\"\n";
    }
};

int main()
{
    cout << "Створюємо аспіранта:\n";
    {
        GraduateStudent grad("Олександр Мельник", "PhD-2025-042",
                             "Оптимізація алгоритмів");
        cout << "\n(об'єкт grad існує)\n\n";
    }
    cout << "Об'єкт grad знищено (вийшов зі scope)\n";
    
    return 0;
}

Порядок деструкції — дзеркальне відображення порядку конструкції:

1. Спочатку викликається деструктор GraduateStudent (найнижчого класу ієрархії).
2. Потім деструктор Student.
3. Нарешті деструктор Person (найвищого класу ієрархії).

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF

rectangle "Послідовність створення (↓)" as Creation #DCFCE7 {
    (Person) as P1
    (Student) as S1
    (GraduateStudent) as G1
    P1 -down-> S1
    S1 -down-> G1
}

rectangle "Послідовність знищення (↑)" as Destruction #FECACA {
    (GraduateStudent) as G2
    (Student) as S2
    (Person) as P2
    G2 -down-> S2 : деструктор викликається першим
    S2 -down-> P2 : деструктор викликається останнім
}

note right of Creation #FEF3C7
  Конструктори: від предка до нащадка
  (будуємо фундамент перед стінами)
end note

note right of Destruction #FEF3C7
  Деструктори: від нащадка до предка
  (руйнуємо стіни перед фундаментом)
end note

@enduml

Чому деструктори викликаються у зворотному порядку? З тих самих причин, що й конструктори — але навпаки:

• Похідний клас використовує ресурси базового класу. Поки виконується деструктор GraduateStudent, він може викликати методи Student та Person для звільнення ресурсів. Якби деструктор Person виконався першим, об'єкт був би частково знищений, і виклики методів призвели б до невизначеної поведінки.
• Правило RAII: ресурси звільняються у зворотному порядку відносно захоплення. Якщо конструктор Student відкрив файл, а конструктор GraduateStudent захопив м'ютекс, то спочатку потрібно звільнити м'ютекс (деструктор GraduateStudent), а потім закрити файл (деструктор Student).

Практичний приклад: ієрархія транспортних засобів

Закріпимо знання на реалістичному прикладі. Побудуємо ієрархію транспортних засобів з правильною ініціалізацією всіх рівнів:

#include <iostream>

using namespace std;

// Базовий клас: транспортний засіб
class Vehicle
{
private:
    string manufacturer;
    int yearOfManufacture;

public:
    Vehicle(string manuf, int year) 
        : manufacturer(manuf), yearOfManufacture(year)
    {
        cout << "  [Vehicle] створено: " << manufacturer 
             << ", рік " << yearOfManufacture << "\n";
    }
    
    ~Vehicle()
    {
        cout << "  [Vehicle] знищено: " << manufacturer << "\n";
    }
    
    string getManufacturer() const { return manufacturer; }
    int getYear() const { return yearOfManufacture; }
};

// Проміжний клас: автомобіль
class Car : public Vehicle
{
private:
    int numberOfDoors;
    string fuelType;

public:
    Car(string manuf, int year, int doors, string fuel)
        : Vehicle(manuf, year), numberOfDoors(doors), fuelType(fuel)
    {
        cout << "  [Car] створено: " << doors << " дверей, паливо: " 
             << fuel << "\n";
    }
    
    ~Car()
    {
        cout << "  [Car] знищено: " << numberOfDoors << " дверей\n";
    }
    
    int getDoors() const { return numberOfDoors; }
    string getFuelType() const { return fuelType; }
};

// Конкретний клас: електромобіль
class ElectricCar : public Car
{
private:
    int batteryCapacity;  // Ємність батареї в кВт·год

public:
    ElectricCar(string manuf, int year, int doors, int battery)
        : Car(manuf, year, doors, "Електрика"), 
          batteryCapacity(battery)
    {
        cout << "  [ElectricCar] створено: батарея " << battery << " кВт·год\n";
    }
    
    ~ElectricCar()
    {
        cout << "  [ElectricCar] знищено: батарея " << batteryCapacity 
             << " кВт·год\n";
    }
    
    int getBatteryCapacity() const { return batteryCapacity; }
};

int main()
{
    cout << "=== Створення електромобіля ===\n\n";
    
    {
        ElectricCar tesla("Tesla", 2024, 4, 75);
        
        cout << "\n--- Використання об'єкта ---\n";
        cout << "Виробник: " << tesla.getManufacturer() << "\n";
        cout << "Рік випуску: " << tesla.getYear() << "\n";
        cout << "Кількість дверей: " << tesla.getDoors() << "\n";
        cout << "Тип палива: " << tesla.getFuelType() << "\n";
        cout << "Ємність батареї: " << tesla.getBatteryCapacity() << " кВт·год\n";
        
        cout << "\n=== Вихід зі scope — знищення об'єкта ===\n\n";
    }
    
    cout << "\n=== Програма завершена ===\n";
    return 0;
}

Цей приклад демонструє всі ключові принципи:

1. Явна передача параметрів: кожен конструктор явно викликає конструктор свого безпосереднього батька та передає йому потрібні параметри.
2. Правило безпосереднього батька: ElectricCar викликає Car(...), Car викликає Vehicle(...). ElectricCar не знає про існування Vehicle.
3. Порядок конструювання: від Vehicle до Car до ElectricCar — фундамент перед стінами.
4. Порядок руйнування: від ElectricCar до Car до Vehicle — стіни перед фундаментом.
5. Доступ до всіх рівнів ієрархії: об'єкт tesla може викликати методи getManufacturer() (з Vehicle), getDoors() (з Car) та getBatteryCapacity() (з ElectricCar).

Типові помилки та як їх уникнути

class Student : public Person
{
public:
    Student(string n, int a, string id) : studentId(id)  // Забули Person(n, a)
    {
    }
};

Student(string n, int a, string id) : Person(n, a), studentId(id) {}

class Student : public Person
{
public:
    Student(string n, int a, string id)
        : name(n), age(a), studentId(id)  // ❌ name і age — не члени Student!
    {
    }
};

Student(string n, int a, string id) : Person(n, a), studentId(id) {}

class GraduateStudent : public Student
{
public:
    GraduateStudent(string n, string id, string topic)
        : Person(n), thesisTopic(topic)  // ❌ Person — не прямий батько!
    {
    }
};

GraduateStudent(string n, string id, string topic)
    : Student(n, id), thesisTopic(topic) {}

class Student : public Person
{
public:
    Student(string n, int a, string id) : studentId(id)
    {
        name = n;   // ❌ Неефективно, не працює з const/посиланнями
        age = a;
    }
};

Student(string n, int a, string id) : Person(n, a), studentId(id) {}

Практичне завдання

int main()
{
    cout << "=== Створення книги ===\n";
    Book book("Чистий код", 2008, "Роберт Мартін");
    
    cout << "\nДані книги:\n";
    cout << "Назва: " << book.getTitle() << "\n";
    cout << "Рік: " << book.getYear() << "\n";
    cout << "Автор: " << book.getAuthor() << "\n";
    
    cout << "\n=== Створення журналу ===\n";
    Magazine magazine("National Geographic", 2025, 3);
    
    cout << "\nДані журналу:\n";
    cout << "Назва: " << magazine.getTitle() << "\n";
    cout << "Рік: " << magazine.getYear() << "\n";
    cout << "Номер випуску: " << magazine.getIssueNumber() << "\n";
    
    cout << "\n=== Знищення об'єктів ===\n";
    return 0;
}

=== Створення книги ===
  [Publication] створено: Чистий код, 2008
  [Book] створено: автор Роберт Мартін

Дані книги:
Назва: Чистий код
Рік: 2008
Автор: Роберт Мартін

=== Створення журналу ===
  [Publication] створено: National Geographic, 2025
  [Magazine] створено: випуск #3

Дані журналу:
Назва: National Geographic
Рік: 2025
Номер випуску: 3

=== Знищення об'єктів ===
  [Magazine] знищено: випуск #3
  [Publication] знищено: National Geographic
  [Book] знищено: автор Роберт Мартін
  [Publication] знищено: Чистий код

#include <iostream>

using namespace std;

class Publication
{
private:
    string title;
    int year;

public:
    Publication(string t, int y) : title(t), year(y)
    {
        cout << "  [Publication] створено: " << title << ", " << year << "\n";
    }
    
    ~Publication()
    {
        cout << "  [Publication] знищено: " << title << "\n";
    }
    
    string getTitle() const { return title; }
    int getYear() const { return year; }
};

class Book : public Publication
{
private:
    string author;

public:
    Book(string t, int y, string a) : Publication(t, y), author(a)
    {
        cout << "  [Book] створено: автор " << author << "\n";
    }
    
    ~Book()
    {
        cout << "  [Book] знищено: автор " << author << "\n";
    }
    
    string getAuthor() const { return author; }
};

class Magazine : public Publication
{
private:
    int issueNumber;

public:
    Magazine(string t, int y, int issue) 
        : Publication(t, y), issueNumber(issue)
    {
        cout << "  [Magazine] створено: випуск #" << issueNumber << "\n";
    }
    
    ~Magazine()
    {
        cout << "  [Magazine] знищено: випуск #" << issueNumber << "\n";
    }
    
    int getIssueNumber() const { return issueNumber; }
};

int main()
{
    cout << "=== Створення книги ===\n";
    Book book("Чистий код", 2008, "Роберт Мартін");
    
    cout << "\nДані книги:\n";
    cout << "Назва: " << book.getTitle() << "\n";
    cout << "Рік: " << book.getYear() << "\n";
    cout << "Автор: " << book.getAuthor() << "\n";
    
    cout << "\n=== Створення журналу ===\n";
    Magazine magazine("National Geographic", 2025, 3);
    
    cout << "\nДані журналу:\n";
    cout << "Назва: " << magazine.getTitle() << "\n";
    cout << "Рік: " << magazine.getYear() << "\n";
    cout << "Номер випуску: " << magazine.getIssueNumber() << "\n";
    
    cout << "\n=== Знищення об'єктів ===\n";
    return 0;
}

Резюме

У цій статті ми дослідили життєвий цикл об'єктів у ієрархіях наслідування — від моменту створення до знищення. Тепер ви розумієте фундаментальні правила роботи конструкторів та деструкторів у багаторівневих ієрархіях і можете коректно проєктувати ініціалізацію складних об'єктних структур.