Пространства имён
Варианты
Действия

try-catch statement

Материал из cppreference.com
< cpp‎ | language

 
 
Язык С++
Общие темы
Управление программой
Операторы условного выполнения
Операторы повторения
Операторы перехода
Функции
объявление функции
объявление лямбда-функции
шаблон функции
спецификатор inline
спецификаторы исключений (устарело)
спецификатор noexcept (C++11)
Исключения
блок try-catch
Пространства имён
объявление пространства имён
псевдонимы пространства имён
Типы
спецификатор decltype (C++11)
Спецификаторы
cv-спецификаторы
спецификаторы продолжительности хранения
спецификатор constexpr (C++11)
спецификатор auto (C++11)
спецификатор alignas (C++11)
Инициализация
Литералы
Выражения
Утилиты
Типы
typedef-объявление
объявление псевдонима типа (C++11)
атрибуты (C++11)
Приведения типов
неявные преобразования
const_cast-преобразование
static_cast-преобразование
dynamic_cast-преобразование
reinterpret_cast-преобразование
C-подобное и функциональное приведение типов
Выделение памяти
Классы
Особые свойства классовых функций
Специальные функции-члены
Шаблоны
шаблон класса
шаблон функции
специализация шаблона
упакованные параметры (C++11)
Разное
Ассемблерные вставки
 
Используется для попытки выполнения соединения-заявления, в то время ловли и обработки исключений, которые, возможно, были брошены в результате этой попытки.
Оригинал:
Used to attempt the execution of a compound-statement, while catching and handling exceptions that may have been thrown as a result of this attempt.
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.

Содержание

[править] Синтаксис

try { statements } catch ( exception-decl ) { statements } (1)
try { statements } catch ( exception-decl-1 ) { statements } catch ( exception-decl-2 ) { statements } (2)
try { statements } catch ( exception-decl ) { statements throw; } (3)
try { statements } catch ( ... ) { statements } (4)
try : ctor-init-list { statements } catch ( exception-decl ) { statements } (5)

[править] Объяснение

более подробную информацию о исключений
Основной синтаксис (1) показывает основные компоненты Try-Catch блока. Во-первых, ключевое слово try инициирует попробуйте-блок, в котором statements может быть выполнен. Отметим, что попытка блок, с момента открытия фигурными скобками своего закрытия, следует тем же правилам области как и любая другая сфера (например, переменные, объявленные в попытке блока не доступны за ее пределами, в том числе из улова блока, который следует ). Тогда, catch заявление выступает в качестве спецификатора типа исключений быть пойманным, если брошен изнутри попробуйте-блок. exception-decl имеет тот же синтаксис, как объявлении параметра в пределах одного параметра декларация функции (кроме того, что типа не может по void, неполного типа, или RValue ссылка (начиная с C++11)). Наконец, соединение-заявление { statements , которые следуют за всеобъемлющее заявление называется обработчика исключений и содержит заявления, которые будут выполнены в соответствии с тем исключением, что был пойман. Типичный код обработки исключений включает в себя регистрацию ошибку, используя альтернативный метод к тому, что была предпринята в попытке блока, или переупаковка исключения в другой выброшенное исключение дополнительной информацией.
Оригинал:
The basic syntax (1) shows the basic components of a try-catch block. First, the keyword try initiates a try-block in which statements can be executed. Note that the try-block, from the opening curly-brace to its closing, follows the same scoping rules as any other scope (e.g. variables declared within the try-block are not available outside of it, including from the catch-block that follows). Then, the catch statement acts as a specifier of the type of exception to be caught if thrown from within the try-block. The exception-decl has the same syntax as the parameter declaration within a single-parameter function declaration (except that the type cannot by void, an incomplete type, or an rvalue-reference (начиная с C++11)). Finally, the compound-statement { statements which follow the catch-statement is called the exception-handler and contains statements to be executed in response to the exception that was caught. Typical exception-handling code includes logging the error, employing an alternative method to what was attempted in the try-block, or re-packaging the exception into another thrown exception with additional information.
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.
В синтаксисе (2), иллюстрации здесь является то, что Try-Catch блока не ограничивается одним улова блока. Так как различные типы исключений может быть брошен изнутри попытке блока, можно указать столько поймать-блоки по мере необходимости обрабатывать все исключения, кто-то хочет, чтобы обращаться. Заметим, однако, что порядок появления всеобъемлющего заявления является важным, выброшенное исключение будет заниматься первый улов блока, по приказу внешний вид, которого exception-decl является действительным матч (и неявные преобразования применяются, а). Другими словами, это не''' лучший матч, который выбран (как в перегрузку функции правил), но первом матче. Если выброшенное исключение соответствует ни один из всеобъемлющего заявления, то исключение осуществляется назад, пока другой ограждающих попытка блок будет достигнута или пока программа не будет прекращено в связи с необработанное исключение.
Оригинал:
In syntax (2), the illustration here is that a try-catch block is not limited to a single catch-block. Since different types of exceptions can be thrown from within the try-block, one can specify as many catch-blocks as necessary to handle all exceptions one wishes to handle. Note, however, that the order of appearance of the catch-statements is important, a thrown exception will be handled by the first catch-block, by order of appearance, whose exception-decl is a valid match (and implicit conversions apply as well). In other words, it is not the best match that is chosen (as in function overloading rules), but the first match. If the thrown exception matches none of the catch-statements, then the exception is carried back until another enclosing try-block is reached or until the program is terminated due to an unhandled exception.
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.
В синтаксисе (3), единственное дополнение является throw; заявление в уловах-блок. В заявлении имеет эффект повторно бросает тот же объект исключения, который был пойман на вылов блока. Это единственный контекст, в котором пустые вбрасывания утверждение справедливо, и это конкретный смысл повторно бросить исключением того, что был пойман и объявлен exception-decl.
Оригинал:
In syntax (3), the only addition is the throw; statement within the catch-block. The statement has the effect of re-throwing the same exception object which was caught by the catch-block. This is the only context in which an empty throw-statement is valid, and it's specific meaning is to re-throw the exception that was caught, and declared as exception-decl.
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.
Синтаксис (4) является так называемая всеобъемлющего блока. Оператор' многоточие ... (буквально, тремя точками) может быть использован в месте exception-decl чтобы указать, что любые типы исключений должны быть пойманы на вылов блока. Этот тип всеобъемлющего блока не полезно для получения любой информации о типе исключением того, что был брошен, и так как большинство объектов исключения классов, производных от <div class="t-tr-text"> зЬй :: исключение
Оригинал:
std::exception
Текст был переведён автоматически через [http://translate.google.com Google Translate].
Вы можете проверить и исправить перевод. Для инструкций кликните [http://en.cppreference.com/w/Cppreference:MachineTranslations сюда].
, как правило, более полезно, чтобы поймать исключение, как catch( std::exception& e ). Тем не менее, основная цель всеобъемлющего блока, чтобы не неперехваченные исключения утечки из функции, что особенно полезно для специальных функций, из которых утечка исключения могут быть опасны, прежде всего, деструктор или динамически связанных внешних функция.
Оригинал:
Syntax (4) is a so-called catch-all block. The ellipsis operator ... (literally, three dots) can be used in-place of the exception-decl to specify that any and all types of exceptions should be caught by the catch-block. This type of catch-all block is not useful for getting any information on the type of exception that was thrown, and since most exception objects are of classes derived from
зЬй :: исключение
Оригинал:
std::exception
Текст был переведён автоматически через [http://translate.google.com Google Translate].
Вы можете проверить и исправить перевод. Для инструкций кликните [http://en.cppreference.com/w/Cppreference:MachineTranslations сюда].
</div>
, it is generally more useful to catch the exception as catch( std::exception& e ). However, the main purpose of a catch-all block is to ensure that no uncaught exceptions are leaked from a function, which is especially useful for special functions from which leaking exceptions can be dangerous, most notably, a destructor or a dynamically-linked external function.
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.
Синтаксис (5) называется функция-попробуйте-блок и может быть использован приложить все тело функции внутри попробуйте-блок (с поймать-блоки после него). Это особенно полезно для перехвата исключений, которые могут быть выброшены во время выполнения инициализации конструктора списка (строительство суб-объекты класса), по сути, это единственный способ сделать это. Эта функция-попробуйте-блок синтаксис редко используется в любом другом контексте, поскольку он не имеет никаких преимуществ по сравнению с традиционным попробуй поймать блок, и в результате синтаксис, как правило, непривлекательны (и незнакомые большинству).
Оригинал:
Syntax (5) is called a function-try-block and can be used to enclose an entire function body inside a try-block (with catch-blocks following it). This is especially useful to catch exceptions which could be thrown during the execution of a constructor's initialization list (construction of sub-objects of a class), in fact, it is the only way to do so. This function-try-block syntax is seldom used in any other context because it has no advantage as compared to a traditional try-catch block, and the resulting syntax is generally unappealing (and unfamiliar to most).
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.

[править] Ключевые слова

try, catch, throw

[править] Пример

В следующем примере показано несколько случаев использования try-catch блока
Оригинал:
The following example demonstrates several usage cases of the try-catch block
Текст был переведён автоматически через Google Translate.
Вы можете проверить и исправить перевод. Для инструкций кликните сюда.

#include <iostream>
#include <vector>
 
int main()
{
    try {
        std::cout << "Throwing an integer exception...\n";
        throw int(42);
    } catch( int i ) {
        std::cout << " the integer exception was caught, with value: " << i << '\n';
    }
 
    try {
        std::cout << "Creating a vector of size 5... \n";
        std::vector<int> v(5);
        std::cout << "Accessing the 11th element of the vector...\n";
        v.at(10);  // the at() function will check the range.
    } catch( std::exception& e) {
        std::cout << " a standard exception was caught, with message '" << e.what() << "'\n";
    }
 
}

Вывод:

Throwing an integer exception...
 the integer exception was caught, with value: 42
Creating a vector of size 5...
Accessing the 11th element of the vector...
 a standard exception was caught, with message 'out_of_range'