{"id":41,"date":"2007-05-14T06:40:55","date_gmt":"2007-05-14T11:40:55","guid":{"rendered":"http:\/\/mariusbancila.ro\/blog\/?p=41"},"modified":"2013-08-13T09:53:57","modified_gmt":"2013-08-13T07:53:57","slug":"debugging-and-exception-handling","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2007\/05\/14\/debugging-and-exception-handling\/","title":{"rendered":"Debugging and Exception Handling"},"content":{"rendered":"

Suppose you have the following code:<\/p>\n

\r\nvoid foo() \r\n{ \r\n  throw std::runtime_error(\"a foo exception!\"); \r\n}  \r\n\r\nint main() \r\n{ \r\n  foo(); \r\n}<\/pre>\n
When running the program, the following window is popped up:<\/p>\n

\nWhen running it in the debugger, a different window is popped up:<\/p>\n

\nand the debugger takes you to the line of code that threw the exception. Looking into the output window, you can see something like this:<\/p>\n
\nFirst-chance exception at 0x7c812a5b in win32test.exe: Microsoft C++ exception: std::runtime_error at memory location 0x0012fd70..
\nUnhandled exception at 0x7c812a5b in win32test.exe: Microsoft C++ exception: std::runtime_error at memory location 0x0012fd70..<\/p><\/blockquote>\n
It shows a first-chance and an unhandle (also knows as second-chance) exception message. When running a program in debugger, the debugger always sees the exception before the program does. Thus, it is said that the debugger gets a first chance to handle the exception. If it does not do that, and the execution continues, the program will see the exception and has a chance to handle it. If the exception is not handled by the program, the debugger gets a second-chance to see the unhandled exception. This is the point when in the absense of the debugger, the program crashes.<\/p>\n
So, what happened with the program above: the debugger saw an exception and printed the first-chance exception message, but did not handle it, and the program was allowed to continue. However, the program did not handle the exception either, and the debugger got its second-chance with the unhandled-exception; the unhandle exception messages was printed and the exception windows was popped.<\/p>\n
Of course, you could change to code in function main to this:<\/p>\n
\r\nint main() \r\n{ \r\n   try { \r\n      foo(); \r\n   } \r\n   catch(...) { \r\n   } \r\n}<\/pre>\n
In this case when run, the program will not crash. But when running in the debugger, you will see the first-chance exception message:<\/p>\n
\nFirst-chance exception at 0x7c812a5b in win32test.exe: Microsoft C++ exception: std::runtime_error at memory location 0x0012fd5c..<\/p><\/blockquote>\n
In this case, the program handled the exception (by doing nothing) and the debugger did not get the second-chance.<\/p>\n
Now, suppose your program is much langer than the several lines of code shown above. When running in the debugger you see first-chance exception messages, but not the second-chance exception message, because your program handles the exception. Should you investigate the cause of the exception, problems arise simply because you don’t know where the exception was thrown. The good news is that you can customize the debugger to break on first-chance exception.<\/p>\n
From the Debug menu, use the Exceptions command to open the dialog that allows you to specify on which exception should the debugger break.<\/p>\n
<\/p>\n
There are several categories:<\/p>\n