Handling exceptions

Исключение exception может быть обработано обработчиком.

Обработчик

Объявление параметра в обработчике описывает тип(ы) исключений, которые могут привести к входу в этот обработчик.

Если параметр объявлен с одним из следующих типов, программа является некорректной:

• тип неполного типа
• тип абстрактного класса

• указатель на неполный тип, отличный от (возможно, cv-квалифицированного) void
• lvalue-ссылка на неполный тип

Если параметр объявлен как имеющий тип «массив T » или тип функции T , тип корректируется до «указатель на T ».

Обработчик с типом параметра T может быть сокращенно назван «обработчиком типа T ».

Сопоставление исключений

Каждый try блок ассоциируется с несколькими обработчиками, эти обработчики формируют последовательность обработчиков. Когда исключение выбрасывается из try блока, обработчики в последовательности проверяются в порядке их следования для сопоставления с исключением.

Обработчик соответствует объекту исключения типа E при выполнении любого из следующих условий:

• Обработчик имеет тип «возможно cv-квалифицированный T » или «lvalue-ссылка на возможно cv-квалифицированный T », и удовлетворяется любое из следующих условий:

• E и T являются одним и тем же типом (игнорируя cv-квалификаторы верхнего уровня).
• T является однозначным публичным базовым классом для E .

• Обработчик имеет тип «возможно cv-квалифицированный T » или const T & , где T является типом указателя или указателя на член, и удовлетворяется любое из следующих условий:

• E — это указатель или указатель на член, который может быть преобразован в T по крайней мере одним из следующих преобразований:

• Стандартное преобразование указателей , не включающее преобразования в указатели на private, protected или неоднозначные классы.

• A qualification conversion .

Обработчик catch ( ... ) перехватывает исключения любого типа. Если он присутствует, он может быть только последним обработчиком в последовательности обработчиков. Этот обработчик может использоваться для гарантии, что никакие неперехваченные исключения не могут покинуть функцию, которая предоставляет nothrow exception guarantee .

try
{
    f();
}
catch (const std::overflow_error& e)
{} // этот блок выполняется, если f() выбрасывает std::overflow_error (правило соответствия типов)
catch (const std::runtime_error& e)
{} // этот блок выполняется, если f() выбрасывает std::underflow_error (правило базового класса)
catch (const std::exception& e)
{} // этот блок выполняется, если f() выбрасывает std::logic_error (правило базового класса)
catch (...)
{} // этот блок выполняется, если f() выбрасывает std::string или int или любой другой несвязанный тип

Если среди обработчиков для блока try не найдено соответствия, поиск подходящего обработчика продолжается в динамически окружающем блоке try того же потока (начиная с C++11) .

Если соответствующий обработчик не найден, std::terminate вызывается; производится ли раскрутка стека перед вызовом std::terminate — определяется реализацией.

Обработка исключений

При выбросе исключения управление передается ближайшему обработчику с соответствующим типом; «ближайший» означает обработчик, для которого составной оператор или список инициализации членов (если присутствует) следующий за ключевым словом try был наиболее недавно введен потоком управления и еще не был завершен.

Инициализация параметра обработчика

Параметр, объявленный в списке параметров (если есть), типа «возможно cv-квалифицированный T » или «ссылка на lvalue на возможно cv-квалифицированный T », инициализируется из объекта исключения , типа E , следующим образом:

• Если T является базовым классом для E , параметр копически инициализируется из lvalue типа T , указывающего на соответствующий базовый подобъект объекта исключения.
• В противном случае параметр копически инициализируется из lvalue типа E , указывающего на объект исключения.

Время жизни параметра завершается при выходе из обработчика, после уничтожения любых объектов с автоматической storage duration инициализированных в пределах обработчика.

Когда параметр объявлен как объект, любые изменения этого объекта не повлияют на объект исключения.

Когда параметр объявлен как ссылка на объект, любые изменения в ссылаемом объекте являются изменениями объекта исключения и вступят в силу, если это исключение будет переброшено.

Активация обработчика

Обработчик считается активным когда инициализация параметра обработчика (если таковой имеется) завершена.

Кроме того, неявный обработчик считается активным, когда std::terminate вызывается из-за операции throw.

Обработчик больше не считается активным, когда обработчик завершает работу.

Исключение с самым последним активированным обработчиком, который все еще активен, называется текущим обрабатываемым исключением . Такое исключение может быть переброшено .

Управление потоком выполнения

compound-statement обработчика является оператором с ограниченным потоком управления :

void f()
{
    goto label;     // ошибка
    try
    {
        goto label; // ошибка
    }
    catch (...)
    {
        goto label: // OK
        label: ;
    }
}

Примечания

Stack unwinding происходит во время передачи управления обработчику. Когда обработчик становится активным, раскрутка стека уже завершена.

Исключение, выброшенное выражением throw throw 0 не соответствует обработчику типа указателя или указателя на член.

Объекты исключений никогда не могут иметь типы массивов или функций, поэтому обработчик ссылки на тип массива или функции никогда не соответствует ни одному объекту исключения.

Можно написать обработчики, которые никогда не будут выполнены, например, разместив обработчик для конечного производного класса после обработчика для соответствующего однозначного открытого базового класса:

try
{
    f();
}
catch (const std::exception& e)
{} // будет выполнено, если f() выбрасывает std::runtime_error
catch (const std::runtime_error& e)
{} // недостижимый код!

Многие реализации чрезмерно расширяют разрешение CWG issue 388 на обработчики ссылок на типы неконстантных указателей:

int i;
try
{
    try
    {
        throw static_cast<float*>(nullptr);
    }
    catch (void*& pv)
    {
        pv = &i;
        throw;
    }
}
catch (const float* pf)
{
    assert(pf == nullptr); // должно выполняться, но не выполняется в MSVC и Clang
}

Ключевые слова

catch

Пример

#include <iostream>
#include <vector>
int main()
{
    try
    {
        std::cout << "Throwing an integer exception...\n";
        throw 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";
        std::cout << v.at(10); // vector::at() throws std::out_of_range
    }
    catch (const std::exception& e) // caught by reference to base
    {
        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'

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также

• try блок
• Выброс исключений
• Обработка исключений