Деструктори та ідіома RAII

#include <iostream>

using namespace std;

class IntArray
{
private:
    int* data;       // Покажчик на динамічний масив
    int size;

public:
    IntArray(int arraySize)
    {
        cout << "Allocating array of size " << arraySize << "\n";
        data = new int[arraySize];    // Виділяємо пам'ять у конструкторі
        size = arraySize;
    }

    void setValue(int index, int value)
    {
        if (index >= 0 && index < size) {
            data[index] = value;
        }
    }

    int getValue(int index) const
    {
        if (index >= 0 && index < size) {
            return data[index];
        }
        return 0;
    }

    int getSize() const { return size; }
};

int main()
{
    IntArray numbers(10);
    
    numbers.setValue(0, 42);
    numbers.setValue(1, 17);
    
    cout << "numbers[0] = " << numbers.getValue(0) << "\n";
    cout << "numbers[1] = " << numbers.getValue(1) << "\n";
    
    // ⚠️ Проблема: хто викличе delete[] для data?
    
    return 0;
}

class IntArray
{
public:
    // ...
    
    void cleanup()
    {
        delete[] data;
        data = nullptr;
    }
};

int main()
{
    IntArray numbers(10);
    numbers.setValue(0, 42);
    
    numbers.cleanup();  // ❌ Користувач повинен пам'ятати про це!
    
    return 0;
}

#include <iostream>

using namespace std;

class IntArray
{
private:
    int* data;
    int size;

public:
    // Конструктор — виділяє ресурс
    IntArray(int arraySize)
    {
        cout << "Constructor: Allocating array of size " << arraySize << "\n";
        data = new int[arraySize];
        size = arraySize;
        
        // Ініціалізуємо масив нулями
        for (int i = 0; i < size; i++) {
            data[i] = 0;
        }
    }

    // Деструктор — звільняє ресурс
    ~IntArray()
    {
        cout << "Destructor: Deallocating array\n";
        delete[] data;  // Звільняємо динамічну пам'ять
    }

    void setValue(int index, int value)
    {
        if (index >= 0 && index < size) {
            data[index] = value;
        }
    }

    int getValue(int index) const
    {
        if (index >= 0 && index < size) {
            return data[index];
        }
        return 0;
    }

    int getSize() const { return size; }
};

int main()
{
    IntArray numbers(5);
    
    numbers.setValue(0, 10);
    numbers.setValue(1, 20);
    
    cout << "numbers[0] = " << numbers.getValue(0) << "\n";
    cout << "numbers[1] = " << numbers.getValue(1) << "\n";
    
    cout << "End of main()\n";
    
    return 0;
}  // ✅ Тут автоматично викликається ~IntArray()!

#include <iostream>

using namespace std;

class Demo
{
private:
    int id;

public:
    Demo(int demoId) : id(demoId)
    {
        cout << "Constructing Demo " << id << "\n";
    }

    ~Demo()
    {
        cout << "Destructing Demo " << id << "\n";
    }

    int getId() const { return id; }
};

int main()
{
    cout << "Start of main()\n";
    
    Demo obj1(1);  // Створено на стеку
    
    {
        Demo obj2(2);  // Створено у вкладеному блоці
        cout << "Inside nested block\n";
    }  // ✅ obj2 виходить з області видимості — деструктор викликається тут
    
    cout << "After nested block\n";
    
    return 0;
}  // ✅ obj1 виходить з області видимості — деструктор викликається тут

int main()
{
    cout << "Start of main()\n";
    
    Demo* ptr1 = new Demo(10);  // Динамічно створений об'єкт
    Demo* ptr2 = new Demo(20);
    
    cout << "Before delete\n";
    
    delete ptr2;  // ✅ Деструктор для obj2 викликається тут
    
    cout << "After deleting ptr2\n";
    
    delete ptr1;  // ✅ Деструктор для obj1 викликається тут
    
    cout << "End of main()\n";
    
    return 0;
}

#include <iostream>

using namespace std;

class Resource
{
private:
    int id;

public:
    Resource(int resourceId) : id(resourceId)
    {
        cout << "  [+] Resource " << id << " acquired\n";
    }

    ~Resource()
    {
        cout << "  [-] Resource " << id << " released\n";
    }
};

int main()
{
    cout << "main() started\n";
    
    Resource r1(1);
    Resource r2(2);
    Resource r3(3);
    
    cout << "main() ending\n";
    
    return 0;
}

class Engine
{
private:
    int power;

public:
    Engine(int hp) : power(hp)
    {
        cout << "    Engine constructor: " << power << " HP\n";
    }

    ~Engine()
    {
        cout << "    Engine destructor: " << power << " HP\n";
    }
};

class Car
{
private:
    Engine engine;
    string model;

public:
    Car(string carModel, int enginePower) : engine(enginePower), model(carModel)
    {
        cout << "  Car constructor: " << model << "\n";
    }

    ~Car()
    {
        cout << "  Car destructor: " << model << "\n";
    }
};

int main()
{
    cout << "Creating car\n";
    Car myCar("Toyota", 150);
    cout << "End of main\n";
    
    return 0;
}

#include <iostream>
#include <cstdio>
#include <stdexcept>

using namespace std;

class FileHandler
{
private:
    FILE* file;
    string filename;

public:
    // Конструктор — захоплює ресурс
    FileHandler(const char* name) : filename(name), file(nullptr)
    {
        file = fopen(name, "w");
        if (file == nullptr) {
            throw runtime_error("Failed to open file");
        }
        cout << "File opened: " << filename << "\n";
    }

    // Деструктор — звільняє ресурс
    ~FileHandler()
    {
        if (file != nullptr) {
            fclose(file);
            cout << "File closed: " << filename << "\n";
        }
    }

    void write(const char* text)
    {
        if (file != nullptr) {
            fprintf(file, "%s\n", text);
        }
    }
};

void processData()
{
    FileHandler output("data.txt");  // Файл відкривається тут
    
    output.write("Line 1");
    output.write("Line 2");
    output.write("Line 3");
    
    // Файл автоматично закриється при виході з функції
}

int main()
{
    cout << "Before processData()\n";
    processData();
    cout << "After processData()\n";
    
    return 0;
}

void riskyFunction()
{
    FileHandler log("log.txt");     // Відкрили файл
    IntArray data(1000);             // Виділили пам'ять
    
    log.write("Processing started");
    
    // Якась небезпечна операція
    throw runtime_error("Something went wrong!");  // ❌ Виняток!
    
    // Цей код не виконається
    log.write("Processing finished");
}

int main()
{
    try {
        riskyFunction();
    }
    catch (const exception& e) {
        cout << "Caught exception: " << e.what() << "\n";
    }
    
    // ✅ Деструктори для log і data все одно виконались!
    // Файл закритий, пам'ять звільнена
    
    return 0;
}

#include <iostream>
#include <cstdlib>  // Для exit()

using namespace std;

class Important
{
private:
    string name;

public:
    Important(string resourceName) : name(resourceName)
    {
        cout << "Acquiring resource: " << name << "\n";
    }

    ~Important()
    {
        cout << "Releasing resource: " << name << "\n";
        // Важлива робота: закриття файлів, запис у БД, тощо
    }
};

int main()
{
    Important resource("Database Connection");
    
    cout << "Doing work...\n";
    
    // Виявлено критичну помилку
    if (true) {
        cout << "Critical error! Calling exit()\n";
        exit(1);  // ❌ Негайне завершення програми
    }
    
    cout << "This will never execute\n";
    
    return 0;
}  // Деструктор ~Important() НЕ викличеться!

int main()
{
    IntArray numbers(3);
    numbers.setValue(0, 10);
    numbers.setValue(1, 20);
    numbers.setValue(2, 30);
    
    // Кінець main() — викликається ~IntArray()
}

~IntArray()
{
    delete[] data;  // Звільняємо динамічний масив
    // data тепер вказує на звільнену пам'ять (dangling pointer)
}