What nuances should be considered when an exception…

Partially constructed object: When an exception is thrown from a constructor, the object is considered not fully created. The destructor will not be called automatically.
Resources: Resources allocated before the exception is thrown inside the constructor must be released. This can be challenging because a partially created object does not have a destructor. Techniques like RAII (Resource Acquisition Is Initialization) are used.
RAII: The best way to handle this situation is to use RAII. Resources (memory, file descriptors, etc.) should be wrapped in classes with destructors that guarantee resource release when leaving the scope (including exception handling). Examples include std::unique_ptr, std::shared_ptr, std::vector, std::fstream.
Exceptions from member initializer lists: If an exception is thrown during the initialization of a class member in the initializer list, the entire object constructor is interrupted, and resources allocated before are not automatically released unless they are wrapped in RAII objects.
Exceptions from constructor body: If an exception is thrown from the constructor body, destructors of already initialized RAII members are called automatically, ensuring cleanup.
Prohibition of exceptions in base class constructors: The C++ standard recommends against throwing exceptions from base class constructors, as this can lead to undefined behavior for derived classes.

Example with RAII for memory management:

class ResourceGuard {
public:
    ResourceGuard(int* ptr) : data_(ptr) {}
    ~ResourceGuard() {
        delete data_; // Guaranteed memory release
    }
private:
    int* data_;
};

class MyClass {
public:
    MyClass() : p_(new int[10]) { // p_ - class member, smart pointer or wrapper
        // Resource allocation. If an exception is thrown here...
        if (condition_fails) {
            throw std::runtime_error("Failure during resource acquisition");
        }
        // Further initialization...
    } // Destructor of p_ (resource_guard) will be called upon constructor exit
private:
    ResourceGuard p_; // RAII wrapper for the resource
};

// Or using std::unique_ptr
class MyClassStd {
public:
    MyClassStd() : p_(std::make_unique<int[]>(10)) {
        if (condition_fails) {
            throw std::runtime_error("Failure");
        }
    } // Destructor of std::unique_ptr will be called automatically
private:
    std::unique_ptr<int[]> p_;
};

What nuances should be considered when an exception is thrown from a constructor?