Advertencia C26440

La función se puede declarar como "noexcept".

Directrices básicas de C++ F.6: si es posible que la función no se produzca, declarela. noexcept

Si el código no se supone que cause ninguna excepción, debe marcarse mediante el noexcept especificador. Esta anotación ayuda a simplificar el control de errores en el lado del código de cliente y permite al compilador realizar más optimizaciones.

Comentarios

• Una función se considera que no se produce si:
  • no tiene instrucciones explícitas throw ;
  • function llama a en su cuerpo, si existe, invocar solo las funciones que no son probables que inicien: constexpr o funciones marcadas con cualquier especificación de excepción que implique un comportamiento que no sea de inicio (incluidas algunas especificaciones no estándar).
• Especificadores no estándar y obsoletos como throw() o __declspec(nothrow) no son equivalentes a noexcept.
• Los especificadores explícitos noexcept(false) y noexcept(true) se respetan adecuadamente.
• Las funciones marcadas como constexpr no deben provocar excepciones y no se analizan.
• La regla también se aplica a las expresiones lambda.
• La lógica no considera las llamadas recursivas como que potencialmente no producen excepciones. Esta lógica puede cambiar en el futuro.

Ejemplo

Todas las funciones excepto el destructor advertirán porque faltan noexcept.

struct S
{
    S() {} // C26455, Default constructor may not throw. Declare it 'noexcept'
    ~S() {}

    S(S&& s) {/*impl*/} // C26439, This kind of function may not throw. Declare it 'noexcept' (f.6)
    S& operator=(S&& s) {/*impl*/} // C26439, This kind of function may not throw. Declare it 'noexcept' (f.6)

    S(const S& s) {/*impl*/} // C26440, This function can be declared 'noexcept'
    S& operator=(const S& s) {/*impl*/} // C26440, This function can be declared 'noexcept'
};

Con noexcept decorando la misma estructura, se quitan todas las advertencias.

struct S
{
    S() noexcept {}
    ~S() {}

    S(S&& s) noexcept {/*impl*/}
    S& operator=(S&& s) noexcept {/*impl*/}

    S(const S& s) noexcept {/*impl*/}
    S& operator=(const S& s) noexcept {/*impl*/}
};