C / C++ / MFC

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

Neels wrote:

it works fine in release mode.

dwThreadId 
    [in] Specifies the identifier of the thread with which the hook procedure is to be associated. If this parameter is zero, the hook procedure is associated with all existing threads running in the same desktop as the calling thread. 

Hakan D wrote:

I some need help about user I/O run-time.