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 throw
inicia (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
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea:Enviar y ver comentarios de