Instrucciones try, throw y catch (C++)

Para implementar el control de excepciones en C++, se usan las expresiones try, throw y catch.

En primer lugar, se debe usar un bloque try para incluir una o más instrucciones que pueden iniciar una excepción.

Una expresión throw indica que se ha producido una condición excepcional, a menudo un error, en un bloque try. Se puede usar un objeto de cualquier tipo como operando de una expresión throw. Normalmente, este objeto se emplea para comunicar información sobre el error. En la mayoría de los casos, se recomienda usar la std::exception clase o una de las clases derivadas definidas en la biblioteca estándar. Si uno de estos no es adecuado, se recomienda derivar su propia clase de excepción de std::exception.

Para controlar las excepciones que se puedan producir, implemente uno o varios bloques catch inmediatamente después de un bloque try. Cada bloque catch especifica el tipo de excepción que puede controlar.

En este ejemplo se muestra un bloque try y sus controladores. Suponga que GetNetworkResource() adquiere datos a través de una conexión de red y que los dos tipos de excepción son clases definidas por el usuario que derivan de std::exception. Observe que las excepciones se detectan en la referencia const de la instrucción catch. Se recomienda producir excepciones por valor y detectarlas mediante la referencia const.

Ejemplo

MyData md;
try {
   // Code that could throw an exception
   md = GetNetworkResource();
}
catch (const networkIOException& e) {
   // Code that executes when an exception of type
   // networkIOException is thrown in the try block
   // ...
   // Log error message in the exception object
   cerr << e.what();
}
catch (const myDataFormatException& e) {
   // Code that handles another exception type
   // ...
   cerr << e.what();
}

// The following syntax shows a throw expression
MyData GetNetworkResource()
{
   // ...
   if (IOSuccess == false)
      throw networkIOException("Unable to connect");
   // ...
   if (readError)
      throw myDataFormatException("Format error");
   // ...
}

Comentarios

El código después de la cláusula try es la sección de código protegida. La expresión throwinicia (es decir, produce) una excepción. El bloque de código que hay detrás de la cláusula catch es el controlador de excepciones. Este es el controlador que detecta la excepción que se produce si los tipos de las expresiones throw y catch son compatibles. Para obtener una lista de las reglas que rigen la coincidencia de tipos en los bloques catch, consulte Cómo se evalúan los bloques de captura. Si la instrucción catch especifica puntos suspensivos (...) en lugar de un tipo, el bloque catch controla todos los tipos de excepciones. Al compilar con la opción , estas pueden incluir excepciones estructuradas de C y excepciones asincrónicas generadas por el /EHa sistema o generadas por la aplicación, como la protección de memoria, la división por cero y las infracciones de punto flotante. Puesto que los bloques catch se procesan por orden de programa para encontrar un tipo coincidente, un controlador de puntos suspensivos debe ser el último controlador del bloque try asociado. Use catch(...) con precaución; no permita que un programa continúe a menos que el bloque catch sepa cómo controlar la excepción específica detectada. Normalmente, un bloque catch(...) se emplea para registrar errores y realizar limpiezas especiales antes de que se detenga la ejecución de un programa.

Una throw expresión que no tiene ningún operando vuelve a generar la excepción que se está controlando actualmente. Se recomienda este formulario al volver a iniciar la excepción, ya que conserva la información del tipo polimórfico de la excepción original. Una expresión así únicamente se debe usar en un controlador catch o en una función a la que se llama desde un controlador catch. El objeto de excepción de nuevo es el objeto de excepción original, no una copia.

try {
   throw CSomeOtherException();
}
catch(...) {
   // Catch all exceptions - dangerous!!!
   // Respond (perhaps only partially) to the exception, then
   // re-throw to pass the exception to some other handler
   // ...
   throw;
}

Consulte también

Procedimientos recomendados de C++ moderno para las excepciones y el control de errores
Palabras clave
Excepciones de C++ no controladas
__uncaught_exception