C ++ manipulação de exceção

As exceções são questões processuais que surgem durante a execução. exceção C ++ refere-se a especial acontece quando o programa estiver em execução, tais como tentativas de dividir pela operação de zero.

Exceção é fornecida uma forma de controle do programa de transferência. C ++ manipulação de exceção envolve trêspalavras-chave: tentativa, captura, lance.

jogar: Quando surgem problemas, o programa irá lançar uma exceção.Isto é feito usando a palavra chavelance para completar.
pegar: onde você quer lidar com o problema, uma exceção é capturado por um manipulador de exceção.captura palavra-chave é usada para capturar exceções.
tentar: tentebloco de código identifica uma exceção específica é ativada. Atrás dele é geralmente seguido por um ou mais blocos de captura.

Se não houver um bloco lança uma exceção, capturar a exceção método usatentar e palavras-chave de captura.tente colocar um bloco de código pode lançar uma exceção, tente código de bloco é conhecido como protegida por código. Use try / catch sintaxe da instrução é a seguinte:

try
{
   // 保护代码
}catch( ExceptionName e1 )
{
   // catch 块
}catch( ExceptionName e2 )
{
   // catch 块
}catch( ExceptionName eN )
{
   // catch 块
}

Se vocêtentar bloco em diferentes contextos lançará uma exceção diferente, desta vez você pode tentar listar várias instruções catchpara capturar diferentes tipos de exceções.

Lançar uma exceção

Você pode usar a instruçãothrow qualquer lugar no bloco de código lança uma exceção.instrução throw operando pode ser qualquer tipo de resultado da expressão expressão determina o tipo de exceção lançada.

O seguinte é uma exceção Tente a zero dividido por exemplos:

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

Capturar a exceção

catch bloco atrás doblocotrypara capturar exceções. Você pode especificar o tipo de exceção que você deseja capturar, que é declarado pela exceção entre parênteses após as decisões de captura de palavras-chave.

try
{
   // 保护代码
}catch( ExceptionName e )
{
  // 处理 ExceptionName 异常的代码
}

O código acima irá capturar uma exceção de tipoExceptionName.Se você quiser pegar bloco pode lidar com qualquer tipo de exceção lançada bloco try, você deve usar a exceção em reticências parênteses ... declaração, como segue:

try
{
   // 保护代码
}catch(...)
{
  // 能处理任何异常的代码
}

Aqui está um exemplo de uma divisão por zero gera uma exceção, ea exceção é detectada no bloco catch.

#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;
}

Desde que jogue um tipoconst char * exceção, portanto, quando a captura essa exceção, devemos usar const char * no bloco catch.Quando o código acima é compilado e executado, ele produz os seguintes resultados:

Division by zero condition!

excepções C ++ padrão

C ++ fornece um conjunto de exceções padrão definidos no<exceção>, podemos usar essas exceções padrão no programa.Eles são baseados na hierarquia de classes pai-filho organizado da seguinte forma:

A tabela que se segue é uma descrição de cada uma hierarquia acima parecem anormais:

异常	描述
std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过new抛出。
std::bad_cast	该异常可以通过dynamic_cast抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过typeid抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument	当使用了无效的参数时，会抛出该异常。
std::length_error	当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator[]()。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
std::overflow_error	当发生数学上溢时，会抛出该异常。
std::range_error	当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error	当发生数学下溢时，会抛出该异常。

Definir uma nova exceção

Você pode definir uma nova exceção por herança classe deexceção e sobrecarga.O exemplo a seguir demonstra como usar a classe std :: exceção a implementar as suas próprias excepções:

#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)
  {
    //其他的错误
  }
}

Isto produz os seguintes resultados:

MyException caught
C++ Exception

Aqui, o que () é uma classe de exceção pública desde que tenha sido sobrecarregado todas as classes de exceção sub.Isso irá retornar a causa dessa exceção gerada.

Anterior: arquivos e fluxos de C ++

Seguinte: C ++ memória dinâmica

C++ curso

C++ Object-Oriented

C++ Tutorial avançado

C++ repositório

C ++ manipulação de exceção

Lançar uma exceção

Capturar a exceção

excepções C ++ padrão

Definir uma nova exceção