intento-excepto la instrucción
Específicos de Microsoft
La sintaxis siguiente describe try-except la instrucción:
__try
{
// guarded code
}
__except ( expression )
{
// exception handler code
}
Comentarios
La instrucción de intento-excepto es una extensión de Microsoft de los lenguajes c y C++ que permite a las aplicaciones de destino para obtener el control cuando los eventos que finalizan normalmente la ejecución del programa aparecen.Estos eventos se denominan excepciones, y el mecanismo para los encarga con excepciones se denominan control estructurado de excepciones.
Para obtener información relacionada, vea instrucción try-finally.
Las excepciones pueden ser de equipo he o basadas en programas.Aunque las aplicaciones no pueden recuperar completamente de excepciones de hardware o software, el control de excepciones estructurado permite mostrar información de error y la captura el estado interno de la aplicación para ayudar a diagnosticar el problema.Esto es especialmente útil para los problemas intermitentes que no se pueden reproducir fácilmente.
[!NOTA]
El control estructurado de excepciones ejecuta Win32 para los archivos de código fuente de c y C++.Sin embargo, no está diseñado específicamente para C++.Puede asegurarse de que el código sea más portátil mediante el control de excepciones de C++.Además, el control de excepciones de C++ es más flexible, ya que puede controlar las excepciones de cualquier tipo.Para los programas de C++, se recomienda utilizar C++ control administra el mecanismo (instrucciones detry, catch, y captura ).
La instrucción compuesta después de la cláusula de __try es el cuerpo o la sección guardada.La instrucción compuesta después de la cláusula de __except es el controlador de excepciones.El controlador especifica un conjunto de acciones que se realizarán si se genera una excepción durante la ejecución del cuerpo de la sección guardada.la ejecución continúa como sigue:
se ejecuta la sección guardada.
Si no se produce ninguna excepción durante la ejecución de la sección guardada, continúa la ejecución de la instrucción después de la cláusula de __except .
Si se produce una excepción durante la ejecución de la sección guardada o en cualquier rutina las llamadas guardadas de la sección,*la expresión * de __except(denominada la expresión de filtro ) se evalúa y el valor determina cómo se controla la excepción.hay tres valores:
Se descartaEXCEPTION_CONTINUE_EXECUTION (– 1) Exception.Continuar la ejecución en el punto donde se ha producido la excepción.
EXCEPTION_CONTINUE_SEARCH (0) Exception no se reconoce.Continúe buscando encima de la pila para un controlador, primero para contener las instrucciones de intento-excepto , entonces para los controladores de mayor prioridad siguiente.
se reconoce **EXCEPTION_EXECUTE_HANDLER (1)**Exception.Transferir el control al controlador de excepciones ejecutando la instrucción compuesta de __except , después continúa la ejecución después de que el bloque de __except .
Dado que la expresión deexcepto de se evalúa como expresión de C/C++., se limita a un valor único, el operador de expresión condicional, o el operador de punto.Si se requiere un procesamiento más extenso, la expresión puede llamar a una rutina que devuelve uno de los tres valores enumerados anteriormente.
Cada aplicación puede tener su propio controlador de excepciones.
No es válido saltar en __try una instrucción, pero válido pasar de una.No se llama al controlador de excepciones si un proceso finaliza en medio de ejecutar una instrucción de intento-excepto .
Para obtener más información, vea el artículo Q315937 de Knowledge Base: CÓMO: Desbordamiento de pila catch en una aplicación de Visual C++.
La palabra clave __leave
La palabra clave de __leave solo es válida dentro de la sección guardada de una instrucción de try-except , y su efecto es saltar al final de la sección guardada.Continúa la ejecución de la primera instrucción después del controlador de excepciones.
Una instrucción de goto también puede saltar de la sección guardada, y no se degrada el rendimiento como en una instrucción de try-finally porque la pila que desenredo no aparece.Sin embargo, se recomienda usar la palabra clave de __leave en lugar de una instrucción de goto porque es menos probable incurrir en una equivocación de programación si la sección guardado sea grande o compleja.
.gif "s58ftw19.collapse_all(es-es,VS.110).gif")
Funciones intrínsecas del control de excepciones estructurado
El control estructurado de excepciones proporciona dos funciones intrínsecas que se pueden utilizar con la instrucción de intento-excepto : GetExceptionCode y GetExceptionInformation.
GetExceptionCode devuelve el código (un entero de 32 bits) de la excepción.
La función intrínseca GetExceptionInformation devuelve un puntero a una estructura que contiene información adicional sobre la excepción.A través de este puntero, puede tener acceso al estado del equipo que existía en el momento de una excepción de hardware.La estructura es la siguiente:
struct _EXCEPTION_POINTERS {
EXCEPTION_RECORD *ExceptionRecord,
CONTEXT *ContextRecord }
_EXCEPTION_RECORD de tipos de puntero y _Contexto son definidas en el archivo EXCPT.H. de inclusión.
Puede utilizar GetExceptionCode dentro del controlador de excepciones.Sin embargo, puede utilizar GetExceptionInformation únicamente en la expresión de filtro de excepciones.La información que elija es normalmente en la pila y ya no está disponible cuando el control se transfiere al controlador de excepciones.
La función intrínseca AbnormalTermination disponible dentro de un controlador de terminación.devuelve 0 si el cuerpo de la instrucción de try-finally finaliza secuencialmente.en todos los demás casos, devuelve 1.
EXCPT.H define algunos nombres alternativos para estos intrínseco:
GetExceptionCode equivale a _exception_code
GetExceptionInformation equivale a _exception_info
AbnormalTermination equivale a _abnormal_termination
Ejemplo
// exceptions_try_except_Statement.cpp
// Example of try-except and try-finally statements
#include <stdio.h>
#include <windows.h> // for EXCEPTION_ACCESS_VIOLATION
#include <excpt.h>
int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep) {
puts("in filter.");
if (code == EXCEPTION_ACCESS_VIOLATION) {
puts("caught AV as expected.");
return EXCEPTION_EXECUTE_HANDLER;
}
else {
puts("didn't catch AV, unexpected.");
return EXCEPTION_CONTINUE_SEARCH;
};
}
int main()
{
int* p = 0x00000000; // pointer to NULL
puts("hello");
__try{
puts("in try");
__try{
puts("in try");
*p = 13; // causes an access violation exception;
}__finally{
puts("in finally. termination: ");
puts(AbnormalTermination() ? " \tabnormal" : "\tnormal");
}
}__except(filter(GetExceptionCode(), GetExceptionInformation())){
puts("in except");
}
puts("world");
}
Output
hello
in try
in try
in filter.
caught AV as expected.
in finally. termination:
abnormal
in except
world
Específico de Microsoft de FINAL
Vea también
Referencia
Escribir un controlador de excepciones