Главная » Языки программирования

Cpp try catch finally

На чтение 12 мин
Содержание
  1. try-except statement
  2. Grammar
  3. Remarks
  4. The __leave keyword
  5. Structured exception handling intrinsic functions
  6. Example
  7. Output
  8. Catch exceptions in Visual C++
  9. Summary
  10. Catch exceptions in Visual C++ .NET
  11. Перехват исключений в Visual C++
  12. Аннотация
  13. Перехват исключений в Visual C++ .NET
  14. Обратная связь

try-except statement

The try-except statement is a Microsoft-specific extension that supports structured exception handling in the C and C++ languages.

 // . . . __try < // guarded code >__except ( /* filter expression */ ) < // termination code >// . . .

Grammar

try-except-statement :
__try compound-statement __except ( expression ) compound-statement

Remarks

The try-except statement is a Microsoft extension to the C and C++ languages. It enables target applications to gain control when events occur that normally terminate program execution. Such events are called structured exceptions, or exceptions for short. The mechanism that deals with these exceptions is called structured exception handling (SEH).

For related information, see the try-finally statement.

Exceptions may be either hardware-based or software-based. Structured exception handling is useful even when applications can’t completely recover from hardware or software exceptions. SEH makes it possible to display error information and trap the internal state of the application to help diagnose the problem. It’s especially useful for intermittent problems that aren’t easy to reproduce.

Structured exception handling works with Win32 for both C and C++ source files. However, it’s not specifically designed for C++. You can ensure that your code is more portable by using C++ exception handling. Also, C++ exception handling is more flexible, in that it can handle exceptions of any type. For C++ programs, we recommend you use native C++ exception-handling: try, catch, and throw statements.

The compound statement after the __try clause is the body or guarded section. The __except expression is also known as the filter expression. Its value determines how the exception is handled. The compound statement after the __except clause is the exception handler. The handler specifies the actions to take if an exception is raised during execution of the body section. Execution proceeds as follows:

  1. The guarded section is executed.
  2. If no exception occurs during execution of the guarded section, execution continues at the statement after the __except clause.
  3. If an exception occurs during execution of the guarded section, or in any routine the guarded section calls, the __except expression is evaluated. There are three possible values:
    • EXCEPTION_CONTINUE_EXECUTION (-1) Exception is dismissed. Continue execution at the point where the exception occurred.
    • EXCEPTION_CONTINUE_SEARCH (0) Exception isn’t recognized. Continue to search up the stack for a handler, first for containing try-except statements, then for handlers with the next highest precedence.
    • EXCEPTION_EXECUTE_HANDLER (1) Exception is recognized. Transfer control to the exception handler by executing the __except compound statement, then continue execution after the __except block.

The __except expression is evaluated as a C expression. It’s limited 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.

Читайте также:  Javascript binary search algorithm

Each application can have its own exception handler.

It’s not valid to jump into a __try statement, but valid to jump out of one. The exception handler isn’t called if a process is terminated in the middle of executing a try-except statement.

For compatibility with previous versions, _try, _except, and _leave are synonyms for __try , __except , and __leave unless compiler option /Za (Disable language extensions) is specified.

The __leave keyword

The __leave keyword is valid only within the guarded section of a try-except statement, and its effect is to jump to the end of the guarded section. Execution continues at the first statement after the exception handler.

A goto statement can also jump out of the guarded section, and it doesn’t degrade performance as it does in a try-finally statement. That’s because stack unwinding doesn’t occur. However, we recommend that you use the __leave keyword rather than a goto statement. The reason is because you’re less likely to make a programming mistake if the guarded section is large or complex.

Structured exception handling intrinsic functions

Structured exception handling provides two intrinsic functions that are available to use with the try-except statement: GetExceptionCode and GetExceptionInformation.

GetExceptionCode returns the code (a 32-bit integer) of the exception.

The intrinsic function GetExceptionInformation returns a pointer to an EXCEPTION_POINTERS structure containing additional information about the exception. Through this pointer, you can access the machine state that existed at the time of a hardware exception. The structure is as follows:

typedef struct _EXCEPTION_POINTERS < PEXCEPTION_RECORD ExceptionRecord; PCONTEXT ContextRecord; >EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;

The pointer types PEXCEPTION_RECORD and PCONTEXT are defined in the include file , and _EXCEPTION_RECORD and _CONTEXT are defined in the include file

You can use GetExceptionCode within the exception handler. However, you can use GetExceptionInformation only within the exception filter expression. The information it points to is generally on the stack and is no longer available when control gets transferred to the exception handler.

The intrinsic function AbnormalTermination is available within a termination handler. It returns 0 if the body of the try-finally statement terminates sequentially. In all other cases, it returns 1.

defines some alternate names for these intrinsics:

GetExceptionCode is equivalent to _exception_code

GetExceptionInformation is equivalent to _exception_info

AbnormalTermination is equivalent to _abnormal_termination

Example

// exceptions_try_except_Statement.cpp // Example of try-except and try-finally statements #include #include // for EXCEPTION_ACCESS_VIOLATION #include int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep) < puts("in filter."); if (code == EXCEPTION_ACCESS_VIOLATION) < puts("caught AV as expected."); return EXCEPTION_EXECUTE_HANDLER; >else < puts("didn't catch AV, unexpected."); return EXCEPTION_CONTINUE_SEARCH; >; > int main() < int* p = 0x00000000; // pointer to NULL puts("hello"); __try < puts("in try"); __try < puts("in try"); *p = 13; // causes an access violation exception; >__finally < puts("in finally. termination: "); puts(AbnormalTermination() ? "\tabnormal" : "\tnormal"); >> __except(filter(GetExceptionCode(), GetExceptionInformation())) < puts("in except"); >puts("world"); >

Output

hello in try in try in filter. caught AV as expected. in finally. termination: abnormal in except world

Источник

Catch exceptions in Visual C++

This article describes how to use a try-catch-finally block to catch an exception.

Читайте также:  Java icon from file

Original product version: Visual C++
Original KB number: 815662

Summary

A try-catch-finally block is a wrapper that you put around any code where an exception might occur. Catching and dealing with exceptions are standard programming tasks.

A try-catch-finally block is made up of the following sections:

  • Any code that may throw an exception is placed inside the try block.
  • If an exception is thrown, the catch block is entered, and the program can do the appropriate operation to recover or to alert the user.
  • The code in the finally block is always executed and can do clean up after an exception occurs. The finally block is optional.

This article refers to the following Microsoft .NET Framework Class Library namespaces: System.IO and System.Security .

Catch exceptions in Visual C++ .NET

  1. Start Visual Studio .NET.
  2. On the File menu, point to New, and then click Project.
  3. In Visual C++, click Visual C++ under Project Types, and then click CLR Console Application under Templates.
  4. In the Name box, type Q815662, and then click OK.
  5. Replace all the code in the Q815662.cpp code window with the following code. The code declares and initializes three variables. The initialization of k causes an error.
#include "stdafx.h" #using #include using namespace System; void _tmain(void) < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >
#include "stdafx.h" #using #include using namespace System; void _tmain(void) < try < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >catch(. ) < Console::WriteLine("An error occurred."); >>

Note The error message from the catch block is displayed instead of the system exception error message.

This statement is always printed. 
#include "stdafx.h" #using #include using namespace System; void _tmain(void) < try < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >catch(. ) < Console::WriteLine("An error occurred."); >__finally //This section is performed regardless of the above processing. < Console::WriteLine(); Console::WriteLine("This statement is always printed"); >> 
#include "stdafx.h" #using #include using namespace System; using namespace System::Reflection; void _tmain(void) < try < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >catch(Exception *e) < Console::WriteLine("An error occurred."); Console::WriteLine(e->Message); // Print the error message. Console::WriteLine(e->StackTrace); //String that contains the stack trace for this exception. > __finally //This section is performed regardless of the above processing. < Console::WriteLine(); Console::WriteLine("This statement is always printed"); >Console::ReadLine(); > 
#include "stdafx.h" #using #include using namespace System; using namespace System::IO; using namespace System::Security; void _tmain(void) < try < File::Create("c:\\temp\\testapp.txt"); //Can fail for a number of resons >// This error may occur if the temp folder does not exist. catch(IOException *ioe) < Console::WriteLine("An IOException exception occurred!"); Console::WriteLine(ioe->ToString()); > // You do not have the appropriate permission to take this action. catch(SecurityException *se) < Console::WriteLine("An SecurityException exception occur") >// Catch all exceptions catch(Exception *e) < Console::WriteLine(e->ToString()); > >

Источник

Читайте также:  Css svg fill currentcolor

Перехват исключений в Visual C++

В этой статье описывается try-catch-finally использование блока для перехвата исключения.

Исходная версия продукта: Visual C++
Исходный номер базы знаний: 815662

Аннотация

Блок try-catch-finally — это оболочка, которая помещается вокруг любого кода, в котором может возникнуть исключение. Перехват и работа с исключениями — это стандартные задачи программирования.

Блок try-catch-finally состоит из следующих разделов:

  • Любой код, который может вызвать исключение, помещается в блок try.
  • Если возникает исключение, catch вводится блок, и программа может выполнить соответствующую операцию для восстановления или оповещения пользователя.
  • Код в блоке finally всегда выполняется и может выполнять очистку после возникновения исключения. Блок finally необязателен.

В этой статье рассматриваются следующие пространства имен библиотеки классов Microsoft платформа .NET Framework: System.IO и System.Security .

Перехват исключений в Visual C++ .NET

  1. Запустите Visual Studio .NET.
  2. В меню Файл выберите пункт Создать и затем пункт Проект.
  3. В Visual C++ щелкните Visual C++ в разделе Типы проектов, а затем выберите консольное приложение CLR в разделе Шаблоны.
  4. В поле Имя введите Q815662 и нажмите кнопку ОК.
  5. Замените весь код в окне кода Q815662.cpp следующим кодом. Код объявляет и инициализирует три переменные. Инициализация k вызывает ошибку.
#include "stdafx.h" #using #include using namespace System; void _tmain(void) < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >
#include "stdafx.h" #using #include using namespace System; void _tmain(void) < try < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >catch(. ) < Console::WriteLine("An error occurred."); >>

Примечание. Сообщение об ошибке catch из блока отображается вместо сообщения об ошибке системного исключения.

This statement is always printed. 
#include "stdafx.h" #using #include using namespace System; void _tmain(void) < try < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >catch(. ) < Console::WriteLine("An error occurred."); >__finally //This section is performed regardless of the above processing. < Console::WriteLine(); Console::WriteLine("This statement is always printed"); >> 
#include "stdafx.h" #using #include using namespace System; using namespace System::Reflection; void _tmain(void) < try < Console::WriteLine("We're going to divide 10 by 0 and see what happens. "); Console::WriteLine(); int i = 10; int j = 0; int k = i/j; //Error on this line. >catch(Exception *e) < Console::WriteLine("An error occurred."); Console::WriteLine(e->Message); // Print the error message. Console::WriteLine(e->StackTrace); //String that contains the stack trace for this exception. > __finally //This section is performed regardless of the above processing. < Console::WriteLine(); Console::WriteLine("This statement is always printed"); >Console::ReadLine(); > 
#include "stdafx.h" #using #include using namespace System; using namespace System::IO; using namespace System::Security; void _tmain(void) < try < File::Create("c:\\temp\\testapp.txt"); //Can fail for a number of resons >// This error may occur if the temp folder does not exist. catch(IOException *ioe) < Console::WriteLine("An IOException exception occurred!"); Console::WriteLine(ioe->ToString()); > // You do not have the appropriate permission to take this action. catch(SecurityException *se) < Console::WriteLine("An SecurityException exception occur") >// Catch all exceptions catch(Exception *e) < Console::WriteLine(e->ToString()); > >

Обратная связь

Были ли сведения на этой странице полезными?

Источник

Оцените статью
© 2023 Программирование