A linguagem C++ fornece o bloco try-catch para captura e tratamento de erros que venham a ocorrer:

try

Possui um bloco de código em que todas as declarações serão executadas ou testadas.

catch

Possui um bloco de código em que as declarações são feitas para tratar algum erro ocorrido try. Nesse bloco temos acesso ao objeto contendo as informações do erro.

Sintaxe

try
{
    //declarações para executar
}
catch (const tipo_excecao objeto_erro)
{
    //declarações para tratar erro
}

Onde

tipo_excecao: tipo de exceção, tipo primitivo ou outro.
objeto_erro: objeto que irá armazenar os dados do erro ocorrido em try.

Exemplo 1

#include <iostream>
using namespace std;

int main()
{
    try
    {
       throw "Ocorreu um erro";
    }
    catch(const char *e)
    {
        cout << "Erro fatal:" << endl;
        cout << e << endl;
    }
    //outros blocos catch aqui

    return 0;
}

Saída

Erro fatal:
Ocorreu um erro

O comando throw utilizado acima será estudado mais adiante em Gerenciando Erros: Exception. Esse comando é usado para lançar manualmente uma exceção.

Uma exceção, de forma simples, é erro que pode ocorrer durante a execução de um programa.

Como um bloco de código try pode ocorrer mais de um tipo de exceção, C++ permite que múltiplos blocos catch possam ser declarados em sequência.

Os blocos catch devem ser declarados a partir das exceptions menos genéricas até a mais genéricas para que a exceção lançada no try não seja capturada de forma errada.

Sintaxe

try
{
    //seu código aqui
}
catch( const exception_mais_especifica &e )
{
    //tratamento aqui
}
catch( const exception_menos_especifica &e )
{
    //tratamento aqui
}
catch( const exception &e )
{
    //exceptions restantes
}

Exemplo 2

#include <iostream>
using namespace std;

int main()
{
    try
    {
       int a = 10, b= 0;
       
       if ( b == 0)
        throw runtime_error("divisao por zero");
       
       if ( a < 0 )
        throw invalid_argument("valor deve ser maior que 0");
        
       //outros erros
    }
    catch(const runtime_error& e){
        cout << e.what() << endl;
    }
    catch(const invalid_argument& e){
        cout << e.what() << endl;
    }
    return 0;
}

Saída

divisao por zero

O método what utilizado acima, será estudado mais adiante em Gerenciando Erros: Exception. Esse método retorna a mensagem de erro associada a exceção.

Por boa prática, as exceções não devem ser lançadas para exibição de mensagens ligadas a validação de dados de entrada do usuário.

Em C++, quando precisamos apenas capturar uma exceção sem a necessidade de tratamentos específicos para um determinado tipo de exceção utilizamos (...) no bloco catch para informar que qualquer tipo de exeção será capturada pelo catch.

Sintaxe

try
{
    //seu código aqui
}
catch( ... )
{
    //tratamento aqui
}

Como pode ser observado na sintaxe acima, quando capturamos uma exceção de forma genérica não temos mais um objeto que armazena as informações do erro ocorrido.

Exemplo 3

#include <iostream>
using namespace std;

int main()
{
    try
    {
       int a = 10, b= 0;

       if ( b == 0)
         throw runtime_error("divisao por zero");
    }
    catch(...)
    {
        cout << "mensagem de erro" << endl;
    }
    return 0;
}

Saída

mensagem de erro