Tratamento de Exceções C++

Uma exceção é um problema que surge durante a execução de um programa. Uma exceção C++ é uma resposta a uma circunstância excepcional que surge enquanto um programa está em execução, como uma tentativa de dividir por zero.

As exceções fornecem uma maneira de transferir o controle de uma parte de um programa para outra. O tratamento de exceções C++ é baseado em três palavras-chave:try, catch, e lançar .

• 
  lançar − Um programa lança uma exceção quando aparece um problema. Isso é feito usando um lance palavra-chave.
  
• 
  pegar − Um programa captura uma exceção com um manipulador de exceção no local de um programa em que você deseja tratar o problema. A pega palavra-chave indica a captura de uma exceção.
  
• 
  tente − Uma tentativa block identifica um bloco de código para o qual determinadas exceções serão ativadas. É seguido por um ou mais blocos catch.
  

Assumindo que um bloco irá gerar uma exceção, um método captura uma exceção usando uma combinação do try e pegue palavras-chave. Um bloco try/catch é colocado em torno do código que pode gerar uma exceção. O código dentro de um bloco try/catch é chamado de código protegido, e a sintaxe para usar try/catch é a seguinte:

try {
   // protected code
} catch( ExceptionName e1 ) {
   // catch block
} catch( ExceptionName e2 ) {
   // catch block
} catch( ExceptionName eN ) {
   // catch block
}

Você pode listar várias capturas para capturar diferentes tipos de exceções caso você tente block gera mais de uma exceção em diferentes situações.

Exceções de lançamento

Exceções podem ser lançadas em qualquer lugar dentro de um bloco de código usando throw declaração. O operando da instrução throw determina um tipo para a exceção e pode ser qualquer expressão e o tipo do resultado da expressão determina o tipo de exceção lançada.

A seguir está um exemplo de lançamento de uma exceção quando ocorre a divisão por zero condição -

double division(int a, int b) {
   if( b == 0 ) {
      throw "Division by zero condition!";
   }
   return (a/b);
}

Capturando exceções

A pega bloquear seguindo o experimentar bloco captura qualquer exceção. Você pode especificar que tipo de exceção deseja capturar e isso é determinado pela declaração de exceção que aparece entre parênteses após a palavra-chave catch.

try {
   // protected code
} catch( ExceptionName e ) {
  // code to handle ExceptionName exception
}

O código acima capturará uma exceção de ExceptionName modelo. Se você quiser especificar que um bloco catch deve lidar com qualquer tipo de exceção que seja lançada em um bloco try, você deve colocar reticências, ..., entre os parênteses que envolvem a declaração de exceção da seguinte forma −

try {
   // protected code
} catch(...) {
  // code to handle any exception
}

O seguinte é um exemplo, que lança uma divisão por exceção zero e a capturamos no bloco catch.
Demonstração ao vivo

#include <iostream>
using namespace std;

double division(int a, int b) {
   if( b == 0 ) {
      throw "Division by zero condition!";
   }
   return (a/b);
}

int main () {
   int x = 50;
   int y = 0;
   double z = 0;
 
   try {
      z = division(x, y);
      cout << z << endl;
   } catch (const char* msg) {
     cerr << msg << endl;
   }

   return 0;
}

Porque estamos levantando uma exceção do tipo const char* , então ao capturar essa exceção, temos que usar const char* no bloco catch. Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado -

Division by zero condition!

Exceções do padrão C++

C++ fornece uma lista de exceções padrão definidas em que podemos usar em nossos programas. Estes são organizados em uma hierarquia de classes pai-filho mostrada abaixo -

Aqui está a pequena descrição de cada exceção mencionada na hierarquia acima -

Sr.Nº	Exceção e descrição
1	std::exceção Uma exceção e classe pai de todas as exceções C++ padrão.
2	std::bad_alloc Isso pode ser lançado por novo .
3	std::bad_cast Isso pode ser gerado por dynamic_cast .
4	std::bad_exception Este é um dispositivo útil para lidar com exceções inesperadas em um programa C++.
5	std::bad_typeid Isso pode ser lançado por typeid .
6	std::logic_error Uma exceção que teoricamente pode ser detectada lendo o código.
7	std::domain_error Esta é uma exceção lançada quando um domínio matematicamente inválido é usado.
8	std::invalid_argument Isso é lançado devido a argumentos inválidos.
9	std::length_error Isso é lançado quando um std::string muito grande é criado.
10	std::out_of_range Isso pode ser lançado pelo método 'at', por exemplo, um std::vector e std::bitset<>::operator[]().
11	std::runtime_error Uma exceção que teoricamente não pode ser detectada lendo o código.
12	std::overflow_error Isso é lançado se ocorrer um estouro matemático.
13	std::range_error Isso ocorre quando você tenta armazenar um valor que está fora do intervalo.
14	std::underflow_error Isso é lançado se ocorrer um underflow matemático.

Definir novas exceções

Você pode definir suas próprias exceções herdando e substituindo exceção funcionalidade de classe. A seguir está o exemplo, que mostra como você pode usar a classe std::exception para implementar sua própria exceção de maneira padrão -
Demonstração ao vivo

#include <iostream>
#include <exception>
using namespace std;

struct MyException : public exception {
   const char * what () const throw () {
      return "C++ Exception";
   }
};
 
int main() {
   try {
      throw MyException();
   } catch(MyException& e) {
      std::cout << "MyException caught" << std::endl;
      std::cout << e.what() << std::endl;
   } catch(std::exception& e) {
      //Other errors
   }
}

Isso produziria o seguinte resultado -

MyException caught
C++ Exception

Aqui, o que() é um método público fornecido pela classe de exceção e foi substituído por todas as classes de exceção filhas. Isso retorna a causa de uma exceção.