O Manipulador Catch-All

Parte da seção Lógica & Fluxo do Journey de C++ da Coddy — lição 52 de 56.

Às vezes, seu programa pode encontrar erros inesperados que não se encaixam nos tipos de exceção específicos para os quais você se planejou. O manipulador genérico catch(...) fornece uma rede de segurança que captura qualquer exceção que não tenha sido tratada por seus blocos catch mais específicos.

O manipulador genérico (catch-all) usa três pontos (...) em vez de especificar um tipo de exceção específico. Ele deve ser colocado após todos os outros blocos catch, já que o C++ os verifica em ordem:

try {
    // Code that might throw various exceptions
} catch (std::invalid_argument& e) {
    std::cout << "Invalid input!" << std::endl;
} catch (std::out_of_range& e) {
    std::cout << "Number too large!" << std::endl;
} catch (...) {
    std::cout << "An unexpected error occurred!" << std::endl;
}

O manipulador catch-all atua como um recurso de fallback para qualquer tipo de exceção que não tenha sido capturada pelos blocos anteriores. Isso é particularmente útil ao trabalhar com códigos que podem lançar exceções que você não previu, garantindo que seu programa não encerre inesperadamente devido a erros não antecipados.

Embora você não possa acessar os detalhes específicos da exceção em um bloco catch-all, você ainda pode fornecer uma mensagem de erro genérica e realizar operações de limpeza para manter seu programa funcionando sem problemas.

Desafio

Fácil

Crie um programa que demonstre o tratamento abrangente de exceções usando múltiplos blocos catch, incluindo um manipulador genérico (catch-all). Este desafio testará sua compreensão de como lidar tanto com tipos específicos de exceção quanto com erros inesperados que não se encaixam em categorias predefinidas.

As seguintes entradas serão fornecidas:

Uma string testType representando o tipo de teste a ser realizado ("string_convert", "math_operation", "array_access" ou "unknown_error")
Uma string value1 que será usada como o dado primário para a operação
Uma string value2 que será usada como dado secundário para algumas operações

Seu programa deve:

Criar uma função chamada performTest que recebe três parâmetros de string
Dentro da função, use uma estrutura if-else para lidar com diferentes tipos de teste:
Se testType for "string_convert": use std::stoi para converter value1 em um inteiro e imprimi-lo
Se testType for "math_operation": converta tanto value1 quanto value2 para inteiros usando std::stoi, depois divida value1 por value2 e imprima o resultado
Se testType for "array_access": crie uma string "Programming", converta value1 para um índice inteiro usando std::stoi, então use str.at(index) para acessar o caractere naquele índice e imprimi-lo. O método .at() lança automaticamente std::out_of_range se o índice for inválido — nenhuma verificação manual de limites é necessária
Se testType for "unknown_error": lance um valor inteiro 999
Na função main, chame performTest dentro de um bloco try
Use múltiplos blocos catch para tratar exceções nesta ordem exata:
Primeiro: std::invalid_argument& para conversões inválidas de string para número
Segundo: std::out_of_range& para números muito grandes ou índice de string fora dos limites
Terceiro: catch(...) como o manipulador genérico para quaisquer outros tipos de exceção

Use o seguinte formato de saída exato:

Para operações bem-sucedidas:

Success: [result_value]

Para diferentes tipos de exceção:

Invalid argument caught
Out of range caught
Unknown exception caught

Lembre-se de que o manipulador genérico catch(...) deve ser colocado por último, já que o C++ verifica os blocos catch em ordem. Este manipulador capturará qualquer tipo de exceção que não tenha sido tratado pelos blocos catch específicos anteriores, incluindo a exceção de inteiro lançada no caso "unknown_error". O manipulador genérico fornece uma rede de segurança para erros inesperados, permitindo ainda o tratamento específico para tipos de exceção conhecidos.

Folha de consulta

O manipulador genérico (catch-all) catch(...) fornece uma rede de segurança que captura qualquer exceção não tratada por blocos catch específicos.

O manipulador genérico usa três pontos (...) e deve ser colocado após todos os outros blocos catch, já que o C++ os verifica em ordem:

try {
    // Código que pode lançar várias exceções
} catch (std::invalid_argument& e) {
    std::cout << "Invalid input!" << std::endl;
} catch (std::out_of_range& e) {
    std::cout << "Number too large!" << std::endl;
} catch (...) {
    std::cout << "An unexpected error occurred!" << std::endl;
}

O manipulador genérico atua como um recurso de fallback para qualquer tipo de exceção que não tenha sido capturada pelos blocos anteriores. Embora você não possa acessar detalhes específicos da exceção em um bloco catch-all, você pode fornecer mensagens de erro genéricas e realizar operações de limpeza.

Experimente você mesmo

#include <iostream>
#include <string>
#include <stdexcept>
using namespace std;

// TODO: Escreva seu código aqui - crie a função performTest

int main() {
    // Ler entrada
    string testType;
    string value1;
    string value2;
    
    cin >> testType;
    cin >> value1;
    cin >> value2;
    
    // TODO: Escreva seu código abaixo - implemente blocos try-catch e chame performTest
    
    return 0;
}