DONT_TEST_NOTNULL C26431C26431 DONT_TEST_NOTNULL

"El tipo de expresión ya es GSL:: not_null."The type of expression is already gsl::not_null. No lo pruebe para comprobar si su valor es NULL. "Do not test it for nullness."

C++ Core Guidelines: F. 23: usar un not_null <T> para indicar que "null" no es un valor válidoC++ Core Guidelines: F.23: Use a not_null<T> to indicate that "null" is not a valid value

El tipo de marcador GSL:: not_null de la biblioteca de compatibilidad de directrices se usa para indicar claramente valores que nunca son punteros nulos.The marker type gsl::not_null from Guidelines Support Library is used to clearly indicate values that are never null pointers. Provoca un error en el caso de que dicha suposición no se mantenga en tiempo de ejecución.It causes a hard failure if such assumption is not held at run time. Por lo tanto, obviamente, no es necesario comprobar si el valor NULL es si Expression se evalúa como un resultado de tipo GSL:: not_null.So, obviously, there is no need to check for nullness if expression evaluates to a result of type gsl::not_null.

ObservacionesRemarks

  • Puesto que GSL:: not_null es una clase contenedora de puntero fino, la regla realiza un seguimiento de las variables temporales que contienen resultados de llamadas al operador de conversión sobrecargado (que devuelve el objeto de puntero incluido).Since gsl::not_null itself is a thin pointer wrapper class, the rule actually tracks temporary variables that hold results from calls to the overloaded conversion operator (which returns contained pointer object). Esta lógica hace que esta regla sea aplicable a las expresiones que implican variables y que finalmente tienen el resultado del tipo GSL:: not_null.Such logic makes this rule applicable to expressions that involve variables and eventually have result of the gsl::not_null type. Pero actualmente omite las expresiones que contienen llamadas a funciones que devuelven GSL:: not_null.But it currently skips expressions that contain function calls returning gsl::not_null.
    • La heurística actual para comprobaciones de nulidad detecta los contextos siguientes:Current heuristic for nullness checks detects the following contexts:
    • expresión de símbolo en una condición de bifurcación, por ejemplo "If (p) {...}";symbol expression in a branch condition, for example "if (p) { ... }";
    • operaciones lógicas no bit a bit;non-bitwise logical operations;
    • operaciones de comparación en las que un operando es una expresión constante que se evalúa como cero.comparison operations where one operand is a constant expression that evaluates to zero.

EjemploExample

las comprobaciones nulas innecesarias revelan la lógica cuestionableunnecessary null checks reveal questionable logic

class type {
public:
    template<class T> bool is() const;
    template<class T> gsl::not_null<const T*> as() const;
    //...
};

class alias_type : public type {
public:
    gsl::not_null<const type*> get_underlying_type() const;
    gsl::not_null<const type*> get_root_type() const
    {
        const auto ut = get_underlying_type();
        if (ut)                                     // C26431
        {
            const auto uat = ut->as<alias_type>();
            if (uat)                                // C26431, also incorrect use of API!
                return uat->get_root_type();

            return ut;
        }

        return this;                                // Alias to nothing? Actually, dead code!
    }
    //...
};

las comprobaciones nulas innecesarias revelan la lógica cuestionableunnecessary null checks reveal questionable logic - reworked

    //...
    gsl::not_null<const type*> get_root_type() const
    {
        const auto ut = get_underlying_type();
        if (ut->is<alias_type>())
            return ut->as<alias_type>()->get_root_type();

        return ut;
    }
    //...