Tratamento de Exceções em OOP

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 81 de 104.

O tratamento de exceções em C++ oferece uma maneira estruturada de detectar e responder a erros em tempo de execução. Na programação orientada a objetos, as exceções se integram naturalmente às hierarquias de classes, permitindo que você crie tipos de erro significativos que carregam contexto sobre o que deu errado.

O mecanismo básico usa três palavras-chave: try, throw e catch. O código que pode falhar fica em um bloco try, os erros são sinalizados com throw, e os blocos catch tratam tipos específicos de exceção:

#include <iostream>
#include <stdexcept>

class BankAccount {
    double balance;
public:
    BankAccount(double b) : balance(b) {}
    
    void withdraw(double amount) {
        if (amount > balance) {
            throw std::runtime_error("Insufficient funds");
        }
        balance -= amount;
    }
    
    double getBalance() const { return balance; }
};

int main() {
    BankAccount account(100.0);
    
    try {
        account.withdraw(150.0);
    } catch (const std::runtime_error& e) {
        std::cout << "Error: " << e.what() << "\n";
    }
    
    std::cout << "Balance: " << account.getBalance() << "\n";
}

A biblioteca padrão do C++ fornece uma hierarquia de classes de exceção com raiz em std::exception. As classes derivadas comuns incluem std::runtime_error para problemas em tempo de execução e std::logic_error para erros de programação. Todas as exceções padrão fornecem um método what() que retorna uma mensagem de erro.

Quando uma exceção é lançada, a pilha é desenrolada — os destruidores são chamados para todos os objetos locais enquanto o programa procura um bloco catch correspondente. Isso garante a limpeza adequada mesmo quando ocorrem erros, e é por isso que RAII e o tratamento de exceções funcionam tão bem juntos.

Desafio

Fácil

Vamos criar uma calculadora de divisão segura que demonstra o tratamento de exceções em um contexto orientado a objetos. Você criará uma classe Calculator que realiza operações de divisão e lança exceções significativas quando algo dá errado; depois, tratará essas exceções de forma adequada no programa principal.

Você organizará seu código em três arquivos:

Calculator.h: Defina sua classe Calculator, que realiza operações matemáticas com o tratamento adequado de erros.
Seu Calculator deve ter um método divide(double numerator, double denominator) que retorna o resultado da divisão. No entanto, se o denominador for zero, ele deverá lançar uma std::runtime_error com a mensagem Division by zero. Se o numerador ou o denominador for negativo, ele deverá lançar uma std::invalid_argument com a mensagem Negative values not allowed.

Inclua também um método safeSqrt(double value) que retorna a raiz quadrada do valor. Se o valor for negativo, lance uma std::runtime_error com a mensagem Cannot compute square root of negative number. Você precisará incluir <cmath> para usar a função sqrt.
Calculator.cpp: Implemente os métodos declarados no arquivo de cabeçalho. Inclua os cabeçalhos necessários (<stdexcept> e <cmath>) e verifique as condições antes de realizar as operações.
main.cpp: Leia três entradas (cada uma em uma linha separada):
1. Tipo de operação: divide ou sqrt
2. Primeiro número (double)
3. Segundo número (double): usado somente para divisão, ignorado para sqrt
Crie um objeto Calculator e realize a operação solicitada dentro de um bloco try. Se a operação for bem-sucedida, imprima Result: [value]. Se uma exceção for capturada, imprima Error: [message], em que a mensagem vem do método what() da exceção.

Após o bloco try-catch (independentemente de ter ocorrido uma exceção), imprima Calculation complete para demonstrar que o programa continua sendo executado após tratar as exceções.

Por exemplo, com as entradas divide, 10 e 2:

Result: 5
Calculation complete

Com as entradas divide, 10 e 0:

Error: Division by zero
Calculation complete

Com as entradas divide, -5 e 2:

Error: Negative values not allowed
Calculation complete

Com as entradas sqrt, 16 e 0:

Result: 4
Calculation complete

Com as entradas sqrt, -9 e 0:

Error: Cannot compute square root of negative number
Calculation complete

Observe como o programa trata os erros de forma adequada, capturando exceções e exibindo mensagens significativas, e depois continua sua execução. Esse padrão mantém o tratamento de erros organizado e sua lógica principal concentrada no caminho de execução esperado.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Calculator.h"

using namespace std;

int main() {
    // Ler entradas
    string operation;
    double num1, num2;
    
    cin >> operation;
    cin >> num1;
    cin >> num2;
    
    // Criar objeto Calculator
    Calculator calc;
    
    // TODO: Use um bloco try-catch para realizar a operação
    // - Se operation for "divide", chame calc.divide(num1, num2)
    // - Se operation for "sqrt", chame calc.safeSqrt(num1)
    // - Em caso de sucesso, imprima "Result: " seguido do resultado
    // - Capture as exceções e imprima "Error: " seguido da mensagem da exceção (use what())
    // - After the try-catch, always print "Calculation complete"
    
    
    return 0;
}