C ++ manejo de excepciones

Las excepciones son cuestiones de procedimiento que surjan durante la ejecución. C ++ excepción se refiere a cuando sucede especial se ejecuta el programa, tales como los intentos de dividir por cero operación.

Excepción se proporciona una forma de control de programas de transferencia. C ++ manejo de excepciones implica trespalabras clave: intentar, captura, tiro.

tiro: Cuando surgen problemas, el programa emitirá una excepción.Esto se hace mediante el uso de la palabra clavede banda para completar.
captura: en la que desea hacer frente al problema, una excepción es atrapada por un manejador de excepciones.palabra clavecatch se utiliza para capturar las excepciones.
Proveedores: tratarcódigo de bloque identifica se activa una excepción específica. Detrás de ella por lo general es seguido por uno o más bloques catch.

Si hay un bloque emite una excepción, coger el método excepción utilizatratar de palabras clave de captura.Trate de colocar un bloque de código que podría lanzar una excepción, intente código de bloque es conocido como protegido por código. sintaxis de la sentencia / catch try de uso es el siguiente:

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

Siintenta bloquear en diferentes contextos se producirá una excepción diferente, esta vez se puede tratar de enumerar varias instrucciones catchpara capturar diferentes tipos de excepciones.

Lanzar una excepción

Puede utilizar la instrucciónthrow en cualquier parte del bloque de código produce una excepción.sentencia throw operando puede ser cualquier tipo de expresión del resultado de la expresión determina el tipo de excepción lanzada.

La siguiente es una excepción Probar cero dividido por ejemplos:

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

Detectar la excepción

bloquecatch detrás delbloquetrypara capturar excepciones. Se puede especificar el tipo de excepción que desea capturar, que se declara en la excepción entre paréntesis después de las decisiones de palabras clave de captura.

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

El código anterior capturar una excepción de tipoExceptionName.Si se desea capturar bloque puede manejar cualquier tipo de excepción lanzada bloque try, debe utilizar la excepción en puntos suspensivos ... paréntesis declaración, de la siguiente manera:

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

Aquí está un ejemplo de una división por cero produce una excepción, y se detecta la excepción en el bloque 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;
}

Como nos tiramos un tipoconst char * excepción, por lo tanto, cuando la captura de esta excepción, debemos usar const char * en el bloque catch.Cuando el código se compila y ejecuta, produce los siguientes resultados:

Division by zero condition!

C ++ estándar excepciones

C ++ proporciona un conjunto de excepciones estándar definidos en<excepción>, podemos utilizar estas excepciones estándar en el programa.Se basan en la jerarquía de clases padre-hijo organizada de la siguiente manera:

La tabla siguiente es una descripción de cada una de la jerarquía por encima de una apariencia anormal:

异常	描述
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 una nueva excepción

Puede definir una nueva excepción por herencia clase deexcepción y la sobrecarga.El siguiente ejemplo muestra cómo utilizar la clase std :: excepción a poner en práctica sus propias excepciones:

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

Esto produce los siguientes resultados:

MyException caught
C++ Exception

Aquí, el método delo que () es una clase de excepción pública, siempre que haya sido sobrecargado todas las clases de excepción sub. Esto devolverá la causa de esta excepción generada.

Anterior: C ++ archivos y secuencias de

Siguiente: C ++ memoria dinámica

C++ curso

C++ Orientado a Objetos

C++ Tutorial avanzado

C++ repositorio

C ++ manejo de excepciones

Lanzar una excepción

Detectar la excepción

C ++ estándar excepciones

Definir una nueva excepción