Advertencia C26432

If you define or delete any default operation in the type 'type-name', define or delete them all (c.21).

C++ Core Guidelines:
C.21: Si define o =elimina cualquier operación predeterminada, defina o =elimine todas ellas

Se supone que las operaciones especiales, como los constructores, alteran el comportamiento de los tipos, por lo que dependen más de los mecanismos del lenguaje para imponer automáticamente escenarios específicos. El ejemplo canónico es la administración de recursos. Si define explícitamente, adopta de forma predeterminada o elimina cualquiera de estas operaciones especiales, con ello indica que quiere evitar cualquier control especial de un tipo. Es incoherente dejar las demás operaciones sin especificar, es decir, definidas implícitamente como eliminadas por el compilador.

Comentarios

Esta comprobación implementa la regla de las cinco, que trata las siguientes operaciones como especiales:

• constructores de copias;
• constructores de movimiento;
• operadores de asignación de copia;
• operadores de asignación de movimiento; y
• destructores.

La regla no comprueba si las operaciones se definen de la misma manera. No pasa nada por mezclar operaciones eliminadas y predeterminadas con las definidas explícitamente. Sin embargo, debe especificar todas ellas si especifica alguna de ellas.

Los niveles de acceso no son importantes y también se pueden mezclar.

La advertencia marca la primera definición de función no estática de un tipo, una vez por tipo.

Ejemplo

En este ejemplo, warning::S define solo un constructor y un destructor predeterminado. La declaración no_warning::S define o elimina las cinco funciones miembro especiales.

// C26432.cpp
namespace warning
{
    struct S
    {
        S() noexcept { ++_count; }
        ~S() { --_count; } // C26432 because only the constructor and destructor are explicitly defined.
        static unsigned _count;
    };
    unsigned S::_count = 0;
}

namespace no_warning
{
    struct S
    {
        S() noexcept { _count++;  }
        S(const S&) = delete;
        S(S&&) = delete;
        S& operator=(const S&) = delete;
        S& operator=(S&&) = delete;
        ~S() { --_count; }
        static unsigned _count;
    };
    unsigned S::_count = 0;
}