Avertissement C26474

Ne pas effectuer de conversion entre les types de pointeur lorsque la conversion peut être implicite.

Recommandations principales en C++ :
Type.1 : Éviter les casts

Dans certains cas, les casts implicites entre les types de pointeur sont sécurisés et ne nécessitent pas l’écriture d’une expression de cast spécifique. Cette règle recherche des instances de casts inutiles que vous pouvez supprimer en toute sécurité.

Notes

L’ID de règle doit être interprété comme « Un cast implicite n’est pas utilisé là où il est acceptable ».

Cette règle s’applique uniquement aux pointeurs. Il vérifie les casts statiques et réinterprète les casts.

Ces cas sont des conversions de pointeur acceptables qui ne doivent pas utiliser d’expressions de cast explicites :

• conversion en nullptr_t;
• conversion en void*;
• conversion d’un type dérivé vers sa base lors de l’appel d’une fonction membre de base qui n’est pas masquée par le type dérivé.

Exemple 1

Une conversion inutile masque une erreur logique dans cet exemple :

template<class T>
bool register_buffer(T buffer) {
    auto p = reinterpret_cast<void*>(buffer); // C26474, also 26490 NO_REINTERPRET_CAST
    // To fix, declare buffer as T*, and use this to define p:
    // auto p = buffer;
    return buffers_.insert(p).second;
}

void merge_bytes(std::uint8_t *left, std::uint8_t *right)
{
    if (left && register_buffer(*left)) { // Unintended dereference!
        // ...
        if (right && register_buffer(right)) {
            // ...
        }
    }
}

Exemple 2

Cet exemple montre comment utiliser des casts pour accéder aux fonctions membres de classe de base :

struct struct_1
{
    void foo();
    void bar();
};

struct struct_2 : struct_1
{
    void foo(); // this definition hides struct_1::foo
};

void fn(struct_2* ps2)
{
    static_cast<struct_1*>(ps2)->foo(); // This cast is necessary to access struct_1::foo
                                        // Alternatively, use ps2->struct_1::foo();
    static_cast<struct_1*>(ps2)->bar(); // This cast is unnecessary and can be done implicitly
}