What can go wrong if an exception is thrown from a constructor?

1. Partially constructed object. If an exception is thrown during object creation, the destructor for that object will not be called automatically, which can lead to resource leaks allocated before the exception.
2. Undefined object state. The object may be in a state where part of its initialization is done, and part is not, making further work with it or its proper deletion difficult.
3. Resource leak. If the constructor allocates resources (memory, file descriptors, etc.) before the exception, these resources may remain unfinished and lead to leaks.
4. Problems with arrays of objects. When creating an array of objects, if the constructor of one of the elements throws an exception, destructors for already successfully created elements will not be called, which also leads to resource leaks.
5. Undefined behavior when using new. If new cannot allocate memory or the object's constructor throws an exception, new throws std::bad_alloc or a constructor exception, respectively. It is important to handle such cases correctly.

It is recommended to avoid throwing exceptions from constructors. As alternatives, the following approaches can be used:

• Use a member function init() that is called after successful object construction and can throw exceptions.
• Use the "Resource Acquisition Is Initialization" (RAII) pattern, where resource management is tied to the object's lifetime. Specialized wrapper classes (e.g., smart pointers, RAII classes for files) guarantee resource release upon scope exit, even in the presence of exceptions.

#include <iostream>
#include <string>
#include <vector>

class Resource {
public:
    Resource(const std::string& name) : name_(name) {
        std::cout << "Resource '" << name_ << "' acquired." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource '" << name_ << "' released." << std::endl;
    }
private:
    std::string name_;
};

class MyClass {
public:
    // Incorrect constructor that throws an exception
    MyClass() : res1_("Res1") {
        std::cout << "MyClass constructor part 1..." << std::endl;
        if (true) { // Simulate error
            throw std::runtime_error("Error during MyClass construction");
        }
        // This part will not be executed, res2_ will not be created
        res2_ = Resource("Res2");
        std::cout << "MyClass constructor part 2..." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
        // Destructor for res1_ will be called automatically
        // But res2_ was not created, its destructor will not be called
    }

private:
    Resource res1_;
    Resource res2_; // Problem: if an exception is thrown before res2_ is initialized
};

// Alternative with init() function
class SafeMyClass {
public:
    SafeMyClass() {
        std::cout << "SafeMyClass constructor called." << std::endl;
    }
    ~SafeMyClass() {
        std::cout << "SafeMyClass destructor called." << std::endl;
    }

    void init() {
        std::cout << "SafeMyClass init() part 1..." << std::endl;
        res1_ = Resource("SafeRes1"); // Initialize member after construction
        if (true) { // Simulate error
             throw std::runtime_error("Error during SafeMyClass initialization");
        }
        res2_ = Resource("SafeRes2");
        std::cout << "SafeMyClass init() part 2..." << std::endl;
    }

private:
    Resource res1_;
    Resource res2_;
};

int main() {
    // Example of using an incorrect constructor
    try {
        MyClass* obj = new MyClass(); // Problem: if constructor fails, obj points to garbage
        delete obj; // Might not happen if exception occurs in constructor
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // Resource Res1 will be released, but if there was a leak before it, it remains
    }
    std::cout << "---" << std::endl;

    // Example of using SafeMyClass
    try {
        SafeMyClass obj; // Constructor does not throw
        obj.init(); // Initialization and potential exception here
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // Destructor of SafeMyClass will be called (for object obj)
        // res1_ destructor will be called correctly, as it was created
        // res2_ was not created, so no leak here
    }

    return 0;
}