C / C++ / MFC

<br />
You should not use structured exception handling in functions that use objects with destructors. If an exception occurs, the destructor cannot be called. Use C++ exception handling instead.

George_George wrote:

So, I do not agree.

George_George wrote:

Any rule in C++ mentioned we can not use object with destructor in __try block with /EHa compile option?

George_George wrote:

Please read to get my analysis,

George_George wrote:

So jhwurmbach, your point is __try and __except does not work with local object with destructor?

George_George wrote:

Is there a rule in MSDN covering this?

led mike wrote:

NO. His point is that C++ spec is not going to discuss vendor specific compiler options. I don't understand why anyone would even need to explain that, it seems so obvious.

George_George wrote:

2. If you change to try/catch, it is fine.

George_George wrote:

I do not know why.

DavidCrow wrote:

As opposed to SEH, C++ exception handling model supports "stack unwinding". It is aware of automatic objects, and it calls their destructors.

George_George wrote:

...we use try/catch, we are still dealing with structured exception...

#include <iostream>
#include <excpt.h>
#include <windows.h>

using namespace std;

class Foo
{
public:
	Foo()
	{
		cout << "constructing Foo" << endl;
	}

	virtual ~Foo()
	{
		cout << "destrucing Foo" << endl;
	}

};

int main()
{
	int* address = NULL;

	try{
		Foo foo1;
		(*address) = 1024;
	} catch (...)
	{
		cout << "access violation caught" << endl;
	}
	return 0;
}
</windows.h></excpt.h></iostream>

zengkun100 wrote:

Foo's destructor will not be called, so compiler generates an error. If you comment this line cout << "destrucing Foo" << endl; int Foo's destructor, and your code will be compiled.

<br />
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.<br />
<br />
 <br />
/EH{s|a}[c][-]<br />
 <br />
<br />
Arguments<br />
a<br />
The exception-handling model that catches asynchronous (structured) and synchronous (C++) exceptions.<br />
<br />
s<br />
The exception-handling model that catches C++ exceptions only and tells the compiler to assume that extern C functions do throw an exception.<br />
<br />
c <br />
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.<br />
<br />
Remarks<br />
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, in Visual C++ 2005, 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.<br />
<br />
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 catch block as aggressively, even if the compiler does not see a throw.<br />
<br />
Use /EHa if you want to catch an exception raised with something other than a throw. The following sample will generate an exception:<br />
<br />
  Copy Code <br />
// compiler_options_EHA.cpp<br />
// compile with: /EHa<br />
#include <iostream><br />
#include <excpt.h><br />
using namespace std;<br />
<br />
void fail() {   // generates SE and attempts to catch it using catch(...)<br />
   try {<br />
      int i = 0, j = 1;<br />
      j /= i;   // This will throw a SE (divide by zero).<br />
   }<br />
   catch(...) {   // catch block will only be executed under /EHa<br />
      cout<<"Caught an exception in catch(...)."<<endl;<br />
   }<br />
}<br />
<br />
int main() {<br />
   __try {<br />
      fail(); <br />
   }<br />
<br />
   // __except will only catch an exception here<br />
   __except(EXCEPTION_EXECUTE_HANDLER) {   <br />
   // if the exception was not caught by the catch(...) inside fail()<br />
      cout << "An exception was caught in __except." << endl;<br />
   }<br />
}<br />
 <br />
<br />
</excpt.h></iostream>

zengkun100 wrote:

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, in Visual C++ 2005, 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.

#include <iostream>

using namespace std;

class Foo
{
public:
	Foo()
	{
		cout << "constructor" << endl;
	}

	virtual ~Foo()
	{
		cout << "destructor" << endl;
	}

};


int main ()
{
	int i = 1;
	int j = 0;
	try{
		Foo foo;
		i = i / j;

	} catch (...)
	{
		cout << "catch structured exception -- division by zero" << endl;
	}
}