{"id":5478,"date":"2018-07-24T20:14:10","date_gmt":"2018-07-24T20:14:10","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-the-noexcept-specifier-and-operator\/"},"modified":"2023-08-11T16:07:17","modified_gmt":"2023-08-11T16:07:17","slug":"c-core-guidelines-the-noexcept-specifier-and-operator","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-the-noexcept-specifier-and-operator\/","title":{"rendered":"C++ Core Guidelines: The noexcept Specifier and Operator"},"content":{"rendered":"

If you skim the remaining rules to error handling, you often read the word noexcept<\/span>. Before I write about the rules for error handling, I will write about the noexcept<\/span> specifier and the noexcept<\/span> operator in this post. <\/p>\n

<\/p>\n

\"teddy<\/p>\n

noexcept<\/span><\/h2>\n

noexcept<\/span> exists in two forms since C++11: as a specifier and as an operator. The C++ core guidelines use the specifier.<\/p>\n

noexcept<\/span> as specifier<\/h3>\n

By declaring a function, a method, or a lambda function as noexcept<\/span>, you specify that these do not throw an exception, and if they throw, you do not care and let the program crash. For simplicity reasons, I will write about function but also mean methods and function templates. There are various ways to express your intention:<\/p>\n

\n
void<\/span> func1<\/span>() noexcept;        \/\/ does not throw<\/span>\nvoid<\/span> func2<\/span>() noexcept(true<\/span>);  \/\/ does not throw<\/span>\nvoid<\/span> func3<\/span>() throw<\/span>();         \/\/ does not throw<\/span>\n\nvoid<\/span> func4<\/span>() noexcept(false<\/span>); \/\/ may throw<\/span>\n<\/pre>\n<\/div>\n
 <\/p>\n
The noexcept<\/span> specification is equivalent to the noexcept(true)<\/span> specification. throw(<\/span>) is equivalent to noexcept(tru<\/span>e) but was deprecated with C++11 and will be removed with C++20. In contrast, noexcept(false)<\/span> means that the function may throw an exception. The noexcept<\/span> specification is part of the function type but can not be used for function overloading. <\/p>\n
There are two good reasons for using noexcept<\/span>: First, an exception specifier documents the function’s behavior. If a function is specified as noexcept<\/span>, it can be safely used in a non-throwing function. Second, it is an optimization opportunity for the compiler. noexcept<\/span> may not call <\/code><\/span>std::unexpected<\/a><\/span><\/span>and may not unwind the stack. The initialization of a container may cheaply move the elements into the container if the move constructor is declared as noexcept. If not declared as noexcept, the elements may be expensive copied into the container.
\n<\/span><\/p>\n
Each function in C++ is either non-throwing or potentially throwing. Potentially throwing means:<\/p>\n
    \n
  1. The function may use a function that may throw.<\/li>\n
  2. The function is declared without a noexcept<\/span> specification.<\/li>\n
  3. The function uses a dynamic_cast<\/span> to a reference type.<\/li>\n<\/ol>\n
    There is an exception to rule 2, that functions are potentially throwing if they have no noexcept<\/span> specification. These exceptions include the following six special member functions. They are implicitly non-throwing. <\/i><\/p>\n