Advertencia C26431

El tipo de expresión 'expr' ya gsl::not_nulles . No pruébelo para la nulación (f.23)

Directrices básicas de C++: F.23: Usar un not_null<T> para indicar que "null" no es un valor válido

El tipo gsl::not_null de marcador de la Biblioteca de compatibilidad de directrices se usa para indicar claramente los valores que nunca son punteros NULOs. Provoca un error difícil si la suposición no se mantiene en tiempo de ejecución. Por lo tanto, obviamente, no es necesario comprobar si una expresión se evalúa como resultado de tipo gsl::not_null.

Comentarios

Dado gsl::not_null que es una clase contenedora de puntero fino, la regla realiza un seguimiento de las variables temporales que contienen los resultados de las llamadas al operador de conversión sobrecargado (que devuelve objetos de puntero contenidos). Esta lógica hace que esta regla sea aplicable a las expresiones que implican variables y, finalmente, tienen un resultado del gsl::not_null tipo. Sin embargo, actualmente omite las expresiones que contienen llamadas de función que devuelven gsl::not_null.

La heurística actual para comprobaciones nulas detecta los siguientes contextos:

• una expresión de símbolo en una condición de rama, por ejemplo if (p) { ... };
• Operaciones lógicas que no son bit a bit;
• Operaciones de comparación en las que un operando es una expresión constante que se evalúa como cero.

Nombre del análisis de código: DONT_TEST_NOTNULL

Ejemplo

Las comprobaciones nulas innecesarias revelan lógica preguntable:

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 muestran lógica interrogable y se vuelven a trabajar:

    //...
    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;
    }
    //...