O que pode contar sobre o trabalho com exceções nos…

Ao chamar o construtor, se ocorrer uma exceção durante a inicialização de um membro da classe ou no corpo do construtor, a execução do construtor é interrompida.

Se a exceção for lançada antes de o objeto estar completamente construído, o destruidor desse objeto não será chamado. Isso pode levar a vazamentos de recursos se o construtor tiver alocado recursos, mas não os tiver liberado antes de lançar a exceção.

Ao trabalhar com exceções em construtores, é importante considerar o seguinte:

Vazamentos de recursos: Se o construtor aloca recursos (como memória, arquivos) e depois lança uma exceção antes de esses recursos serem liberados, ocorrerá um vazamento.
Objetos parcialmente construídos: Em caso de exceção, o objeto pode ficar em um estado incompleto. Acessar tal objeto após capturar a exceção pode levar a um comportamento indefinido.

Para trabalhar com segurança com exceções em construtores, aplicam-se as seguintes abordagens:

A idiomática RAII (Resource Acquisition Is Initialization): Os recursos são encapsulados em classes cujos construtores os alocam e cujos destrutores os liberam. Assim, se uma exceção for lançada, os destrutores são chamados automaticamente para os membros já construídos e classes base, garantindo a liberação de recursos.

// Exemplo de uso de RAII com ponteiros inteligentes
#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Recurso adquirido\n"; }
    ~Resource() { std::cout << "Recurso liberado\n"; }
};

class MyClass {
    std::unique_ptr<Resource> res;
public:
    MyClass() : res(std::make_unique<Resource>()) {
        // Aqui pode ocorrer uma exceção
        // Se ocorrer uma exceção, o unique_ptr liberará o recurso
        if (true) { // Simulação de condição para exceção
            // throw std::runtime_error("Erro no construtor");
        }
    }
};

// int main() {
//     try {
//         MyClass obj;
//     } catch (const std::exception& e) {
//         std::cerr << "Exceção capturada: " << e.what() << std::endl;
//     }
//     return 0;
// }

Função membro init(): No construtor, realiza-se apenas uma inicialização simples, e a lógica mais complexa, que pode lançar uma exceção, é colocada em uma função membro init(), que é chamada após a criação bem-sucedida do objeto.

class MyClass {
    // Membros da classe
public:
    MyClass() {
        // Inicialização simples, sem lançar exceções
    }

    void init() {
        // Lógica mais complexa, que pode lançar exceção
        if (true) { // Simulação de condição para exceção
            // throw std::runtime_error("Erro na inicialização");
        }
    }
};

// int main() {
//     try {
//         MyClass obj;
//         obj.init(); // Chamando init após criar o objeto
//     } catch (const std::exception& e) {
//         std::cerr << "Exceção capturada: " << e.what() << std::endl;
//     }
//     return 0;
// }

Construtores delegados (C++11 e versões posteriores): Permitem que construtores chamem outros construtores da mesma classe. Isso pode ser útil para centralizar a lógica de inicialização, incluindo possíveis lançamentos de exceções.

class MyClass {
    int value;
public:
    MyClass(int v) : value(v) {
        if (v < 0) {
            throw std::invalid_argument("O valor deve ser não negativo");
        }
        // Lógica adicional de inicialização
    }

    MyClass() : MyClass(0) {} // Construtor delegado
};

// int main() {
//     try {
//         MyClass obj1(10);
//         MyClass obj2(-5); // Lançará exceção
//     } catch (const std::exception& e) {
//         std::cerr << "Exceção capturada: " << e.what() << std::endl;
//     }
//     return 0;
// }

A escolha da abordagem depende da complexidade da inicialização e das características específicas da classe. RAII é o método preferido para gerenciamento de recursos em C++.

O que pode contar sobre o trabalho com exceções nos construtores?