/EH (Exception Handling Model)

Specifies the model of exception handling to be used by the compiler and destroys C++ objects that will go out of scope as a result of the exception. If /EH is not specified, the compiler will catch structured and C++ exceptions, but will not destroy C++ objects that will go out of scope as a result of the exception.

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

Arguments

• a
  The exception-handling model that catches asynchronous (structured) and synchronous (C+) exceptions.

• s
  The exception-handling model that catches C++ exceptions only and tells the compiler to assume that extern C functions do throw an exception.

• c
  If used with s (/EHsc), catches C++ exceptions only and tells the compiler to assume that extern C functions never throw a C++ exception. /EHca is equivalent to /EHa.

Remarks

Use /EHs to specify the synchronous exception handling model (C++ exception handling without structured exception handling exceptions). If you use /EHs, then your catch clause will not catch asynchronous exceptions. Also, all objects in scope when the asynchronous exception is generated will not be destroyed even if the asynchronous exception is handled. Under /EHs, catch(...) will only catch C++ exceptions. Access violations and System.Exception exceptions will not be caught.

Use /EHa to specify the asynchronous exception handling model (C++ exception handling with structured exception handling exceptions). /EHa may result in a less performant image because the compiler will not optimize a try block as aggressively, even if the compiler does not see a throw.

Use /EHa if you want to catch an exception raised with something other than a throw. The following sample will generate an exception:

// 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;
   }
}

The /EHc option requires that /EHs or /EHa is specified. Using /clr (Common Language Runtime Compilation) implies /EHa (/clr /EHa is redundant). The compiler will generate an error if /EHs[c] is used after /clr. Optimizations will not affect this behavior. When an exception is caught, the compiler invokes the class destructor or destructors for the object or objects that are in the same scope as the exception. When an exception is not caught, those destructors are not run.

See _set_se_translator for exception handling restrictions under /clr.

The option can be cleared by the symbol -. For example, /EHsc- is interpreted as /EHs /EHc- and is equivalent to /EHs.

See Exception Handling: Default Synchronous Exception Model for more information.

To set this compiler option in the Visual Studio development environment

1. Open the project's Property Pages dialog box. For details, see How to: Open Project Property Pages.

2. Click the C/C++ folder.

3. Click the Code Generation property page.

4. Modify the Enable C++ Exceptions property.

Alternately, you can use the following procedure:

To set this compiler option in the Visual Studio development environment

1. Click the C/C++ folder.

2. Click the Code Generation property page.

3. Set Enable C++ Exceptions to No.

4. Click the Command Line property page.

5. Type the compiler option in the Additional Options box.

To set this compiler option programmatically

• See ExceptionHandling.

See Also

Reference

Compiler Options

Setting Compiler Options

Exception Specifications

Change History