Динамическая спецификация исключений (до C++17)

Перечисляет исключения, которые функция может выбрасывать напрямую или косвенно.

Синтаксис

Явное динамическое указание на исключения должно появляться только в деклараторе функции для типа функции, указателя на тип функции, ссылки на тип функции или указателя на член-функцию типа, являющегося основным типом объявления или определения, или в таком типе, появляющемся в качестве параметра или возвращаемого типа в деклараторе функции.

void f() throw(int);            // OK: function declaration
void (*pf)() throw (int);       // OK: pointer to function declaration
void g(void pfa() throw(int));  // OK: pointer to function parameter declaration
typedef int (*pf)() throw(int); // Error: typedef declaration

Объяснение

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

Неполные типы, указатели или ссылки на неполные типы, кроме cv void*, и типов ссылок на правые значения(с C++11) не допускаются в спецификации исключений. Массивы и типы функций, если используются, приводятся к соответствующим типам указателей, а верхний уровень квалификаторов cv также удаляется. Допускаются пакеты параметров(с C++11).

Динамическая спецификация исключений, у которой множество приведенных типов пусто (после расширения любых пакетов)(с C++11), считается не выбрасывающей исключения. Функция с не выбрасывающей динамической спецификацией исключений не допускает исключений.

Динамическая спецификация исключений не считается частью типа функции.

Если функция выбрасывает исключение типа, не указанного в её спецификации исключений, то функция std::unexpected вызывается. По умолчанию вызывается std::terminate, но она может быть заменена пользовательской функцией (через std::set_unexpected), которая может вызвать std::terminate или сгенерировать исключение. Если исключение, сгенерированное std::unexpected, принимается спецификацией исключений, откат стека продолжается как обычно. Если это не так, но std::bad_exception разрешено спецификацией исключений, то выбрасывается std::bad_exception. В противном случае вызывается std::terminate.

Инициализация

Динамическая спецификация исключений специализации шаблона функций не инициализируется вместе с объявлением функции; она инициализируется только при необходимости (как определено ниже).

Динамическая спецификация исключений неявно объявленной специальной функции-члена также вычисляется только при необходимости (в частности, неявное объявление функции-члена производного класса не требует инициализации спецификации исключений базовой функции-члена).

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

Динамическая спецификация исключений функции считается необходимой в следующих контекстах:

• в выражении, где функция выбирается с помощью разрешения перегрузки
• функция используется odr-используется
• функция была бы odr-использована, но появляется в неоцениваемом операнде

template<class T>
T f() throw(std::array<char, sizeof(T)>);
 
int main()
{
    decltype(f<void>()) *p; // f unevaluated, but exception specification is needed
                            // error because instantiation of the exception specification
                            // calculates sizeof(void)
}

• спецификация необходима для сравнения с другим объявлением функции (например, при переопределении виртуальной функции или при явной специализации шаблона функции)
• в определении функции
• спецификация необходима, потому что неявно определённой специальной функции-члену необходимо проверить её, чтобы определить собственную спецификацию исключений (это происходит только тогда, когда спецификация неявно определённой специальной функции-члена сама по себе необходима).

Возможные исключения

Каждая функция f, указатель на функцию pf, и указатель на функцию-член pmf имеет множество потенциальных исключений, которое состоит из типов, которые могут быть сгенерированы. Множество всех типов означает, что может быть сгенерировано любое исключение. Это множество определяется следующим образом:

Примечание: для неявно объявленных специальных функций-членов (конструкторов, операторов присваивания и деструкторов) и для конструкторов наследования(с C++11), множество потенциальных исключений представляет собой комбинацию множеств потенциальных исключений всего, что они вызывают: конструкторы/операторы присваивания/деструкторы невариантных нестатических данных, прямых базовых классов и, при необходимости, виртуальных базовых классов (включая выражения аргументов по умолчанию, как всегда).

У каждого выражения e есть множество потенциальных исключений. Множество пусто, если e является ядерным константным выражением, в противном случае оно представляет собой объединение множеств потенциальных исключений всех непосредственных подвыражений e (включая выражения аргументов по умолчанию), в сочетании с другим множеством, которое зависит от формы e, как показано ниже:

void f() throw(int); // f()'s set is "int"
void g();            // g()'s set is the set of all types
 
struct A { A(); };                  // "new A"'s set is the set of all types
struct B { B() noexcept; };         // "B()"'s set is empty
struct D() { D() throw (double); }; // new D's set is the set of all types

Все неявно объявленные функции-члены и конструкторы наследования (с C++11) имеют спецификации исключений, выбираемые следующим образом:

• Если множество потенциальных исключений содержит все типы, неявная спецификация исключений разрешает все исключения (спецификация исключений считается присутствующей, даже если она не выражается в коде и ведет себя так, как если бы спецификации исключений не было)(до C++11)является noexcept(false)(с C++11).
• В противном случае, если множество потенциальных исключений не пусто, неявная спецификация исключений перечисляет каждый тип из множества.
• В противном случае, неявная спецификация исключений throw()(до C++11)noexcept(true)(с C++11).

struct A
{
    A(int = (A(5), 0)) noexcept;
    A(const A&) throw();
    A(A&&) throw();
    ~A() throw(X);
};
 
struct B
{
    B() throw();
    B(const B&) = default; // exception specification is "noexcept(true)"
    B(B&&, int = (throw Y(), 0)) noexcept;
    ~B() throw(Y);
};
 
int n = 7;
struct D : public A, public B
{
    // May throw an exception of a type that would match a handler of type
    // std​::​bad_array_new_length, but does not throw a bad allocation exception
    (void*) new (std::nothrow) int[n];
 
    // D may have the following implicitly-declared members:
    // D::D() throw(X, std::bad_array_new_length);
    // D::D(const D&) noexcept(true);
    // D::D(D&&) throw(Y);
    // D::~D() throw(X, Y);
};

Примечания

Clang учитывает изменение правила создания динамической спецификации исключений в C++11, введенное в CWG1330, см. LLVM #56349.

Пример

#include <cstdlib>
#include <exception>
#include <iostream>
 
class X {};
class Y {};
class Z : public X {};
class W {};
 
void f() throw(X, Y) 
{
    bool n = false;
 
    if (n)
        throw X(); // OK, would call std::terminate()
    if (n)
        throw Z(); // also OK
 
    throw W(); // will call std::unexpected()
}
 
void handler()
{
    std::cerr << "That was unexpected!\n"; // flush needed
    std::abort();
}
 
int main()
{
    std::set_unexpected(handler);
    f();
}

That was unexpected!

Отчеты об ошибках

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

См. также