Microsoft C++ language extension: try-except statement structured exceptions

Microsoft-specific

try-except The try-except

try-except-statement
：__try compound-statement

__except ( expression ) compound-statement

__try The compound statement after the clause It is a protected festival. The compound statement after the __except

1. Execute the protected section.

2. If no exception occurs during the execution of the protected section, execution continues with the statement after the __except

   clause.

3. If an exception occurs during the execution of the protected section or in any routine called by the protected section, the __except
   expression is evaluated and the value returned will determine how the exception is handled. There are three values:

4. EXCEPTION_CONTINUE_SEARCH The exception is not recognized. Continue searching up the stack for handlers, first the try-except
   statement, then the handler with the next highest priority.

5. EXCEPTION_CONTINUE_EXECUTION

   The exception was recognized but was closed. Execution continues from the point where the exception occurred.

   EXCEPTION_EXECUTE_HANDLER Exceptions can be identified. Transfer control of the exception handler by executing the __except

   compound statement, and then continue execution where the exception occurred.

Because the __except

Structured exception handling applies to C and C source files. However, this is not designed specifically for C. You can ensure increased code portability by using C exception handling. Furthermore, the C exception handling mechanism is much more flexible as it can handle any type of exception.

For C programs, C exception handling should be used instead of structured exception handling. For more information, see Exception Handling in the C Language Reference.

Each routine in the application can have its own exception handler. __except Expressions are executed within the scope of the __try body. This means it can access any local variables declared there. The

__leave keyword is valid in the try-except statement block. The effect of __leave is to jump to the end of the try-except block. Execution will resume after the exception handler ends. Although the goto statement can be used to achieve the same result, the goto statement causes the stack to be unrolled. Since the __leave statement does not involve stack unwinding, it is more efficient.

Using the longjmp runtime function to exit the try-except statement is considered an abnormal termination. Jumping to the __try statement is illegal, but jumping out of the statement is legal. If a process cancels while executing a try-except statement, the exception handler will not be called.

Example

The following are examples of exception handlers and termination handlers. For more information about termination handlers, see the try-finally statement.

.  
.  
.  
puts("hello");  
__try{  
   puts("in try");  
   __try{  
      puts("in try");  
      RAISE_AN_EXCEPTION();  
   }__finally{  
      puts("in finally");  
   }  
}__except( puts("in filter"), EXCEPTION_EXECUTE_HANDLER ){  
   puts("in except");  
}  
puts("world");

This is the output of the example above, with comments added to the right:

hello  
in try              /* fall into try                     */  
in try              /* fall into nested try                */  
in filter           /* execute filter; returns 1 so accept  */  
in finally          /* unwind nested finally                */  
in except           /* transfer control to selected handler */  
world               /* flow out of handler                  */

End Microsoft-specific

Related articles:

C language PHP helloworld extension

c language structure function: the difference between PHP language structure and function

The above is the detailed content of Microsoft C++ language extension: try-except statement structured exceptions. For more information, please follow other related articles on the PHP Chinese website!