18.1.4. Спецификатор исключения noexcept

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

По новому стандарту функция может пообещать не передавать исключения при помощи спецификации noexcept. Ключевое слово noexcept после списка параметров функции означает, что функция не будет передавать исключений:

void recoup (int) noexcept; // не будет передавать исключений

void alloc(int);            // может передавать исключения

Эти объявления заявляют, что функция recoup() не будет передавать исключений, а функция alloc() могла бы. Считается, что к функции recoup() применена спецификация запрета передачи исключения (nonthrowing specification).

Спецификатор noexcept должен присутствовать во всех объявлениях и в соответствующем определении функции или ни в одном из них. Спецификатор предшествует замыкающему типу (см. раздел 6.3.3). Спецификатор noexcept можно определить также в объявлении и определении указателя на функцию. Он неприменим к псевдониму типа или определению типа (typedef). В функции-члене спецификатор noexcept следует за квалификатором const или квалификатором ссылки, но предшествует квалификаторам final, override и = 0 у виртуальной функции.

Нарушение спецификации исключения

Важно понимать, что компилятор не проверяет спецификацию noexcept во время компиляции. Фактически компилятору не разрешено отклонять функцию со спецификатором noexcept просто потому, что она содержит оператор throw или вызывает функцию, которая может передавать исключение (однако хорошие компиляторы предупреждают о таких случаях):

// эта функция компилируется, хоть она и нарушает свою спецификацию

// исключения

void f() noexcept   // обещание не передавать исключений

{

 throw exception(); // нарушает спецификацию исключения

}

В результате вполне вероятно, что функция, обещавшая не передавать исключений, фактически передаст его. Если такая функция передаст исключение, для соблюдения обещания во время выполнения вызывается функция terminate(). Результат прокрутки стека непредсказуем. Таким образом, спецификатор noexcept следует использовать в двух случаях: если есть уверенность, что функция не будет передавать исключений, или если совершенно неизвестно, как справиться с ошибкой.

Спецификация запрета передачи исключения фактически обещает вызывающей стороне такой функции, что ей не придется иметь дела с исключениями. Функция либо не передаст исключения, либо вся программа закончит работу; в любом случае вызывающей стороне не нести ответственность за исключения.

Во время компиляции компилятор может вообще не проверять спецификации исключения.

Совместимость с прежней версией. Спецификации исключения

У прежних версий языка С++ была более сложная схема спецификаций исключения, позволяющая определять типы исключений, которые могла бы передавать функция. Функция может определить ключевое слово throw, сопровождаемое заключенным в скобки списком типов, которые могла бы передать функция. Спецификатор throw располагается в том же месте, где и спецификатор noexcept в текущем языке.

Этот подход никогда широко не использовался и не рекомендован в текущем стандарте. Хотя один случай использования более сложной старой схемы распространен довольно широко. Функция, обозначенная как throw(), обещает не передавать никаких исключений:

void recoup(int) noexcept; // recoup() не передает ничего

void recoup(int) throw();  // эквивалентное объявление

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

Аргументы спецификации noexcept

Спецификатор noexcept получает необязательный аргумент, тип которого должен быть преобразуем в тип bool: если аргументом будет true, то функция не будет передавать исключений; если false — то может:

void recoup(int) noexcept(true); // не будет передавать исключений

void alloc(int) noexcept(false); // может передавать исключения

Оператор noexcept

Аргументы спецификатора noexcept зачастую создаются с использованием оператора noexcept. Оператор noexcept — унарный, возвращающий константное логическое выражение r-значения, означающее способность данного выражения передавать исключения. Подобно оператору sizeof (см. раздел 4.9), оператор noexcept не вычисляет свой операнд.

Например, следующее выражение возвращает значение true:

noexcept(recoup(i)) // true, если вызов функции recoup() не может

                    // передать исключение, и false в противном случае

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

Оператор noexcept можно использовать для формирования спецификатора исключения следующим образом:

void f() noexcept(noexcept(g())); // f() имеет тот же спецификатор

                                  // исключения, что и g()

Если функция g() обещает не передавать исключений, то f() также не будет. Если g() не имеет спецификатора исключения или имеет спецификатор, позволяющий передачу исключений, то функция f() также может передавать их.

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

Спецификации исключения и указатели, виртуальные функции, функции управления копированием

Хотя спецификатор noexcept не является частью типа функции, наличие у функции спецификатора исключения влияет на ее использование.

Указатель на функцию и функция, на которую указывает этот указатель, должны иметь одинаковые спецификации. Таким образом, если объявлен указатель со спецификатором запрета передачи исключения, то использовать этот указатель можно только для указания на функции с подобным спецификатором. Указатель на функцию, способную передавать исключение, определенный явно или неявно, может указывать на любую функцию, даже если она обещает не передавать исключения:

// recoup() и pf1() обещают не передавать исключений

void (*pf1)(int) noexcept = recoup;

// ok: recoup() не будет передавать исключений; и не имеет значения,

// что pf2() может

void (*pf2)(int) = recoup;

pf1 = alloc; // ошибка: alloc() может передать исключение, но pf1()

             // обещала, что не будет

pf2 = alloc; // ok: pf2() и alloc() могли бы передать исключение

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

class Base {

public:

 virtual double f1(double) noexcept; // не передает исключения

 virtual int f2() noexcept(false);   // может передавать

 virtual void f3();                  // может передавать

};

class Derived : public Base {

public:

 double f1(double);         // ошибка: Base::f1() обещает не передавать

 int f2() noexcept (false); // ok: та же спецификация, как у Base::f2()

 void f3() noexcept;        // ok: Derived:f3() ограничена строже

};

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

Упражнения раздела 18.1.4

Упражнение 18.8. Пересмотрите написанные классы и добавьте соответствующие спецификации исключения к их конструкторам и деструкторам. Если вы полагаете, что некоторые из ваших деструкторов могли бы передавать исключения, изменить код так, чтобы это было невозможно.