Namespaces
Variants

noexcept operator (since C++11)

From cppreference.net
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous

El operador noexcept realiza una verificación en tiempo de compilación que devuelve true si una expresión está declarada para no lanzar ninguna excepción.

Puede utilizarse dentro del especificador noexcept specifier de una plantilla de función para declarar que la función lanzará excepciones para algunos tipos pero no para otros.

Contenidos

Sintaxis

noexcept( expresión )

Retorna un prvalue de tipo bool . El resultado es true si el conjunto de excepciones potenciales de la expresión está vacío (hasta C++17) la expresión está especificada como no lanzadora (desde C++17) , y false en caso contrario.

expression es un operando no evaluado .

Si expression es un prvalue, temporary materialization se aplica.

(since C++17)

Notas

Aunque noexcept ( expr ) sea true , una evaluación de expr aún puede lanzar una excepción como resultado de encontrar comportamiento indefinido.

Si expression es de un tipo clase o (posiblemente multidimensional) array del mismo, la materialización temporal requiere que el destructor no sea eliminado y sea accesible.

(since C++17)

Palabras clave

noexcept

Ejemplo

#include <iostream>
#include <utility>
#include <vector>
void may_throw();
void no_throw() noexcept;
auto lmay_throw = []{};
auto lno_throw = []() noexcept {};
class T
{
public:
    ~T(){} // dtor previene move ctor
           // copy ctor es noexcept
};
class U
{
public:
    ~U(){} // dtor previene move ctor
           // copy ctor es noexcept(false)
    std::vector<int> v;
};
class V
{
public:
    std::vector<int> v;
};
int main()
{
    T t;
    U u;
    V v;
    std::cout << std::boolalpha <<
        "may_throw() is noexcept(" << noexcept(may_throw()) << ")\n"
        "no_throw() is noexcept(" << noexcept(no_throw()) << ")\n"
        "lmay_throw() is noexcept(" << noexcept(lmay_throw()) << ")\n"
        "lno_throw() is noexcept(" << noexcept(lno_throw()) << ")\n"
        "~T() is noexcept(" << noexcept(std::declval<T>().~T()) << ")\n"
        // nota: las siguientes pruebas también requieren que ~T() sea noexcept porque
        // la expresión dentro de noexcept construye y destruye un temporal
        "T(rvalue T) is noexcept(" << noexcept(T(std::declval<T>())) << ")\n"
        "T(lvalue T) is noexcept(" << noexcept(T(t)) << ")\n"
        "U(rvalue U) is noexcept(" << noexcept(U(std::declval<U>())) << ")\n"
        "U(lvalue U) is noexcept(" << noexcept(U(u)) << ")\n"
        "V(rvalue V) is noexcept(" << noexcept(V(std::declval<V>())) << ")\n"
        "V(lvalue V) is noexcept(" << noexcept(V(v)) << ")\n";
}

Salida:

may_throw() is noexcept(false)
no_throw() is noexcept(true)
lmay_throw() is noexcept(false)
lno_throw() is noexcept(true)
~T() is noexcept(true)
T(rvalue T) is noexcept(true)
T(lvalue T) is noexcept(true)
U(rvalue U) is noexcept(false)
U(lvalue U) is noexcept(false)
V(rvalue V) is noexcept(true)
V(lvalue V) is noexcept(false)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
CWG 2722 C++17 no estaba claro si la materialización temporal
se aplica si expression es un prvalue
se aplica
en este caso
CWG 2792 C++11 se requería que el operador noexcept determinara si las excepciones
pueden ser lanzadas en caso de encontrar comportamiento indefinido
no requerido

Véase también

noexcept especificador (C++11) especifica si una función puede lanzar excepciones
Especificación de excepciones dinámicas (hasta C++17) especifica qué excepciones son lanzadas por una función (obsoleto en C++11)