/EH (Modelo de control de excepciones)

Artículo
06/09/2015

Especifica el tipo de control de excepciones que debe utilizar el compilador y destruye los objetos de C++ que estarán fuera de ámbito como resultado de una excepción. Si no se especifica /EH, el compilador detectará las excepciones C++ y las excepciones estructuradas asincrónicas, pero no destruirá los objetos de C++ que estén fuera de ámbito como resultado de una excepción asincrónica.

/EH{s|a}[c][-]

Argumentos

a
Modelo de control de excepciones que detecta las excepciones asincrónicas (estructuradas) y sincrónicas (C++).
s
Modelo de control de excepciones que solo detecta las excepciones de C++ e indica al compilador que presuponga que las funciones declaradas como extern "C" pueden generar una excepción.
c
Si se utiliza con s (/EHsc), captura solo las excepciones de C++ e indica al compilador que suponga que las funciones declaradas como extern "C" jamás inician una excepción de C++.

/EHca es equivalente a /EHa.

Comentarios

La opción del compilador /EHa se usa para admitir el control de excepciones estructuradas asincrónicas (SEH) con la cláusula nativa de C++ catch(...). Para implementar SEH sin especificar /EHa, puede utilizar la sintaxis __try, __except y __finally. Aunque Windows y Visual C++ admiten SEH, se recomienda encarecidamente utilizar el control de excepciones de C++, que se ajusta a la norma ISO (/EHs o /EHsc), ya que hace que el código sea más portátil y flexible. Sin embargo, en cierto código existente o en determinados tipos de programas, por ejemplo, en código compilado para admitir Common Language Runtime (/clr (Compilación de Common Language Runtime)), es posible que tenga que seguir utilizando SEH. Para obtener más información, vea Control de excepciones estructurado (C/C++).

Puede ser peligroso especificar /EHa e intentar controlar todas las excepciones mediante catch(...). En la mayoría de los casos, las excepciones asincrónicas son irrecuperables y podrían considerarse fatales. La detección y continuidad de estas excepciones puede dañar el proceso y generar errores que son difíciles de encontrar y corregir.

Si utiliza /EHs o /EHsc, la cláusula catch(...) no detectará las excepciones estructuradas asincrónicas. Las infracciones de acceso y las excepciones Exception administradas no se detectan, y, cuando se genera una excepción asincrónica, los objetos de no se destruyen, incluso aunque se controle esta excepción asincrónica.

Si utiliza /EHa, la imagen podría ser más grande y no ejecutarse bien, ya que el compilador no optimiza un bloque try bloqueado de forma tan agresiva y deja filtros de excepción que llaman automáticamente a los destructores de todos los objetos locales aunque el compilador no vea ningún código que pueda producir una excepción de C++. De este modo, la pila puede desenredarse con seguridad en las excepciones asincrónicas, así como en las excepciones de C++. Cuando se utiliza /EHs, el compilador presupone que las excepciones solo pueden producirse en una instrucción throw o en una llamada de función. Esto permite que el compilador elimine el código para realizar el seguimiento de vida útil de muchos objetos que no se pueden desenredar, y esto puede reducir significativamente el tamaño del código.

Es recomendable que no vincule objetos compilados mediante /EHa con objetos compilados mediante /EHs en el mismo módulo ejecutable. Si tiene que controlar una excepción asincrónica mediante /EHa en cualquier parte del módulo, utilice /EHa para compilar todo el código del módulo. Puede utilizar la sintaxis del control de excepciones estructurado en el mismo módulo que el código compilado mediante /EHs, pero no puede combinar la sintaxis de SEH con try, throw y catch en la misma función.

Utilice /EHa si desea detectar una excepción producida por un método distinto de throw. En este ejemplo se genera y se detecta una excepción estructurada:

// compiler_options_EHA.cpp
// compile with: /EHa
#include <iostream>
#include <excpt.h>
using namespace std;

void fail() {   // generates SE and attempts to catch it using catch(...)
   try {
      int i = 0, j = 1;
      j /= i;   // This will throw a SE (divide by zero).
      printf("%d", j); 
   }
   catch(...) {   // catch block will only be executed under /EHa
      cout<<"Caught an exception in catch(...)."<<endl;
   }
}

int main() {
   __try {
      fail(); 
   }

   // __except will only catch an exception here
   __except(EXCEPTION_EXECUTE_HANDLER) {   
   // if the exception was not caught by the catch(...) inside fail()
      cout << "An exception was caught in __except." << endl;
   }
}

La opción /EHc requiere que se haya especificado /EHs o /EHa. El uso de /clr implica /EHa (es decir, /clr /EHa es redundante). El compilador genera un error si /EHs[c] se utiliza después de /clr. Las optimizaciones no afectan a este comportamiento. Cuando se detecta una excepción, el compilador invoca al destructor o a los destructores de clase correspondientes a los objetos que están en el mismo ámbito que la excepción. Si no se detecta ninguna excepción, no se ejecutan estos destructores.

Para obtener información sobre las restricciones del control de excepciones en /clr, vea _set_se_translator.

La opción puede eliminarse mediante el símbolo -. Por ejemplo, /EHsc- se interpreta como /EHs /EHc- y es equivalente a /EHs.

Para establecer esta opción del compilador en el entorno de desarrollo de Visual Studio

Abra el cuadro de diálogo Páginas de propiedades del proyecto. Para obtener información detallada, vea Cómo: Abrir páginas de propiedades del proyecto.
En el panel izquierdo, expanda Propiedades de configuración, C/C++ y Generación de código.
Modifique la propiedad Habilitar excepciones de C++.

O bien, establezca Habilitar excepciones de C++ en No y, en la página de propiedades Línea de comandos, en el cuadro Opciones adicionales, agregue la opción del compilador.