Pourquoi est-il autorisé d'accéder aux membres statiques à l'aide d'un pointeur nul en C ?

Accès aux membres statiques à l'aide de pointeurs nuls en C

Contexte

Considérez le programme suivant :

<code class="cpp">#include <iostream>
class Demo
{
public:
    static void func() { std::cout << "func() called" << std::endl; }
    static int num = 9;
};

int main()
{
    Demo* d = nullptr;
    d->func();
    std::cout << d->num << std::endl;
    return 0;
}

Question

Ce programme se compile et s'exécute sans erreur, tandis que l'accès aux membres statiques via un pointeur nul est généralement considéré comme un comportement indéfini. Pourquoi est-ce autorisé ?

Réponse

TL;DR :

Le programme donné ne déclenche pas de comportement indéfini car l'indirection via un pointeur nul n'est pas intrinsèquement problématique à moins qu'elle n'implique d'autres opérations qui reposent sur une identité d'objet valide.

Explication :

La question de savoir si l'indirection via des pointeurs nuls est un comportement intrinsèquement indéfini a été un sujet de débat . La seule opération discutable dans le programme est l'évaluation de l'expression d->a.

d->a est équivalent à (*d).a en raison des règles de déréférencement de pointeur. Cependant, même si *d n'est pas défini, l'expression *d est toujours évaluée, surtout lorsque son résultat est ignoré, comme dans le cas de d->a. Ce comportement est bien défini.

Le comportement avec les membres statiques est différent de l'accès aux membres non statiques via un pointeur nul, ce qui devrait en effet déclencher un comportement non défini puisqu'il implique une identité d'objet invalide. L'accès aux membres statiques, en revanche, ne nécessite pas d'identité d'objet et leur comportement est explicitement défini dans la norme.

Considérations supplémentaires

• Le numéro 232 du CWG met en évidence l'écart entre le traitement d'indirection via des pointeurs nuls dans la norme C, ce qui suggère que cela ne peut pas conduire intrinsèquement à un comportement indéfini.
• Le numéro 315 du CWG aborde spécifiquement le scénario d'appel d'une fonction membre via un pointeur nul, réitérant que l'indirection elle-même est pas une erreur à moins qu'elle n'implique d'autres opérations qui reposent sur l'identité de l'objet.
• La suppression du résultat d'une expression (expression de valeur supprimée) est traitée différemment de l'accès à la valeur, ce qui peut déclencher des erreurs en fonction du contexte.

Conclusion

Le programme donné ne pose aucun mal car l'évaluation de *d est autorisée dans le contexte de l'accès aux membres statiques. L'indirection via des pointeurs nuls à elle seule ne provoque pas nécessairement un comportement indéfini, mais il est important d'être conscient des risques potentiels associés à d'autres opérations nécessitant une identité d'objet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!