Konstruktorlarda istisnolar bilan ishlash haqida nima…

Konstruktor chaqirilganda, agar sinf a'zosi yoki konstruktor tanasida istisno yuzaga kelsa, konstruktor bajarilishi to'xtatiladi.

Agar istisno ob'ekt to'liq qurilmaganidan oldin yuzaga kelsa, bu ob'ektning destruktori chaqirilmaydi. Bu, agar konstruktor resurslarni ajratgan bo'lsa va ularni istisno yuzaga kelishidan oldin bo'shatmagan bo'lsa, resurslar oqib ketishiga olib kelishi mumkin.

Konstruktorlarda istisnolar bilan ishlashda quyidagilarni hisobga olish muhim:

Resurslar oqib ketishi: Agar konstruktor resurslarni (masalan, xotira, fayllar) ajratib, so'ngra istisno yuzaga kelsa, oqib ketadi.
Qisman qurilgan ob'ektlar: Istisno holatida, ob'ekt to'liq bo'lmagan holatda qolishi mumkin. Bunday ob'ektga istisno ushlangandan so'ng murojaat qilish noma'lum xatti-harakatlarga olib kelishi mumkin.

Xavfsiz ishlash uchun quyidagi yondashuvlar qo'llaniladi:

RAII (Resource Acquisition Is Initialization) idiomi: Resurslar, konstruktorlar ularni ajratadigan va destruktorlar ularni bo'shatadigan sinflarda inkapsullangan. Bu bilan, istisno yuzaga kelsa, destruktorlar avtomatik ravishda chaqiriladi va allaqachon qurilgan a'zolar va asosiy sinflar uchun resurslar bo'shatiladi.

// RAII bilan aqlli ko'rsatkichlardan foydalanish misoli
#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resurs olindi\n"; }
    ~Resource() { std::cout << "Resurs bo'shatildi\n"; }
};

class MyClass {
    std::unique_ptr<Resource> res;
public:
    MyClass() : res(std::make_unique<Resource>()) {
        // Bu yerda istisno yuzaga kelishi mumkin
        // Agar yuzaga kelsa, unique_ptr resursni bo'shatadi
        if (true) { // Simulyatsiya sharti
            // throw std::runtime_error("Xato konstruktor");
        }
    }
};

// int main() {
//     try {
//         MyClass obj;
//     } catch (const std::exception& e) {
//         std::cerr << "Ushlangan istisno: " << e.what() << std::endl;
//     }
//     return 0;
// }

init() a'zo funksiyasi: Konstruktor faqat oddiy boshlang'ich qiymatlarni bajaradi, va istisno chiqarishi mumkin bo'lgan murakkab logika init() a'zo funksiyasiga o'tkaziladi, va u ob'ekt muvaffaqiyatli yaratilgandan so'ng chaqiriladi.

class MyClass {
    // Sinf a'zolari
public:
    MyClass() {
        // Oddiy boshlang'ich, istisno chiqarmaydi
    }

    void init() {
        // Murakkabroq logika, istisno chiqarishi mumkin
        if (true) { // Simulyatsiya sharti
            // throw std::runtime_error("Boshlashda xato");
        }
    }
};

// int main() {
//     try {
//         MyClass obj;
//         obj.init(); // Ob'ekt yaratgandan so'ng init chaqiriladi
//     } catch (const std::exception& e) {
//         std::cerr << "Ushlangan istisno: " << e.what() << std::endl;
//     }
//     return 0;
// }

Delegat konstruktorlar (C++11 va undan keyingi versiyalar): Bu konstruktorlar, sinfning boshqa konstruktorlarini chaqirishga imkon beradi. Bu, boshlash logikasini markazlashtirish uchun foydali bo'lishi mumkin, shu jumladan, ehtimoliy istisnolarni boshqarish.

class MyClass {
    int value;
public:
    MyClass(int v) : value(v) {
        if (v < 0) {
            throw std::invalid_argument("Qiymat manfiy bo'lishi mumkin emas");
        }
        // Qo'shimcha boshlash logikasi
    }

    MyClass() : MyClass(0) {} // Delegat konstruktor
};

// int main() {
//     try {
//         MyClass obj1(10);
//         MyClass obj2(-5); // Istisno chiqaradi
//     } catch (const std::exception& e) {
//         std::cerr << "Ushlangan istisno: " << e.what() << std::endl;
//     }
//     return 0;
// }

Yondashuv tanlovi, boshlashning murakkabligi va sinfning xususiyatlariga bog'liq. RAII, C++da resurslarni boshqarish uchun afzal qilingan usuldir.

Konstruktorlarda istisnolar bilan ishlash haqida nima deyish mumkin?