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

Microsoft-specific

try-except The try-except

statement is a Microsoft C language extension that enables an application to terminate execution normally when an event occurs. to gain control of the program. Such events are called exceptions, and the mechanism for handling exceptions is called structured exception handling.

Exceptions may be hardware or software based. Even if an application cannot fully recover from a hardware or software exception, structured exception handling can help diagnose the problem by displaying error information and capturing the application's internal state. This is particularly useful for intermittent problems that cannot be easily reproduced.

Syntax

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

clause is the exception handler. If an exception is thrown during the execution of a control section, the handler specifies a series of actions to be taken. The execution process is as follows:

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

expression will be evaluated as a C expression, it is restricted to a single value, the conditional expression operator, or the comma operator. If more extensive processing is required, the expression can call a routine that returns one of the three values ​​listed above. illustrate

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.

illustrate

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!