Quand l'invocation d'une fonction membre d'une instance null entraîner un comportement non défini?

Considérons le code suivant:

#include <iostream>

struct foo
{
    //(a):
    void bar() { std::cout << "gman was here" << std::endl; }

    //(b):
    void baz() { x = 5; }

    int x;
};

int main()
{
    foo* f = 0;

    f->bar(); //(a)
    f->baz(); //(b)
}

Nous nous attendons à ce (b) de crash, car il n'y a pas de membre correspondant x pour le pointeur null. Dans la pratique, (a) ne tombe pas en panne parce que le this pointeur n'est jamais utilisé.

Parce que (b) déréférence le this pointeur ((*this).x = 5;), et this est null, le programme entre dans un comportement indéfini, comme référence à la valeur null est toujours dit d'être un comportement indéfini.

Ne (a) entraîner un comportement non défini? Si les deux fonctions (et x) sont statiques?

  • Si les deux fonctions sont statiques, comment pourrait-x être appelé à l'intérieur de baz? (x est un non-variable membre statique)
  • Faire semblant x a été faite trop statique. 🙂
  • Sûrement, mais pour le cas (a), il fonctionne de la même dans tous les cas, je.e, la fonction est appelée. Cependant, le remplacement de la valeur du pointeur de 0 à 1 (par exemple, par le biais de reinterpret_cast), c'est presque invariablement se bloque toujours. La valeur de l'allocation de 0 et donc NUL, comme dans le cas a, représente quelque chose de spécial pour le compilateur ? Pourquoi faut-il toujours bloquer avec toute autre valeur attribuée à elle?
  • Intéressant: Venez à la prochaine révision du C++, il n'y aura pas plus d'un déréférencement de pointeurs à tous. Nous allons maintenant effectuer indirection via des pointeurs. Pour en savoir plus, veuillez effectuer indirection par le biais de ce lien: N3362
  • Whoa! C'est tout un changement.
  • L'invocation d'une fonction membre sur un pointeur null est toujours un comportement indéfini. Juste en regardant ton code, je peux déjà sentir le comportement non défini rampant lentement jusqu'à mon cou!

InformationsquelleAutor GManNickG | 2010-03-18
  1. 111

    Les deux (a) et (b) entraîner un comportement indéfini. C'est toujours un comportement indéfini d'appeler une fonction membre par l'intermédiaire d'un pointeur null. Si la fonction est statique, c'est techniquement pas défini en tant que bien, mais il y a du litige.

    La première chose est de comprendre pourquoi c'est un comportement indéfini déréférencer un pointeur null. En C++03, il y a effectivement un peu d'ambiguïté ici.

    Bien que "déréférencement d'un pointeur null entraîne un comportement non défini" est mentionné dans les notes dans les deux §1.9/4 et §8.3.2/4, il n'est jamais explicitement mentionnée. (Les Notes sont non-normatif.)

    Cependant, on peut essayer de déduire à partir de §3.10/2:

    Une lvalue se réfère à un objet ou une fonction.

    Lors de la déférence, le résultat est une lvalue. Un pointeur null ne pas référence à un objet, par conséquent, lorsque nous utilisons la lvalue nous avoir un comportement indéfini. Le problème est que la phrase précédente, il n'est jamais dit, alors, que signifie "utiliser" la lvalue? Tout de même générer, à tous, ou à utiliser dans le cadre plus formel sentiment d'effectuer des lvalue-à-rvalue de conversion?

    Peu importe, il ne peut absolument pas être convertie en une rvalue (§4.1/1):

    Si l'objet pour lequel la lvalue se réfère n'est pas un objet de type T et n'est pas un objet d'un type dérivé de T, ou si l'objet est non initialisée, un programme qui nécessite cette conversion a un comportement indéfini.

    Ici, il est certainement un comportement indéfini.

    L'ambiguïté vient de si oui ou non c'est un comportement indéfini de déférence mais ne pas les utiliser la valeur d'un pointeur non valide (c'est, obtenir une lvalue, mais pas de le convertir à une rvalue). Si non, alors int *i = 0; *i; &(*i); est bien définie. C'est un active problème.

    De sorte que nous avons une stricte "déréférencer un pointeur null, obtenir un comportement indéfini" de la vue et de la faiblesse de l'utilisation d'un déréférencé pointeur null, obtenir un comportement indéfini" point de vue.

    Maintenant nous pencher sur la question.

    Oui, (a) résultats dans un comportement indéfini. En fait, si this est null alors quel que soit le contenu de la fonction le résultat est indéfini.

    Cela résulte du §5.2.5/3:

    Si E1 de type “pointeur vers la classe X”, alors l'expression E1->E2 est convertie en une forme équivalente (*(E1)).E2;

    *(E1) va entraîner un comportement non défini avec une interprétation stricte, et .E2 convertit en une rvalue, faisant d'elle un comportement indéfini de la faiblesse de l'interprétation.

    Il suit aussi que c'est un comportement indéfini directement à partir de (§9.3.1/1):

    Si une fonction membre non statique d'une classe de X est appelée pour un objet qui n'est pas de type X, ou d'un type dérivé de X, le comportement est indéfini.

    Avec des fonctions statiques, la stricte contre la faiblesse de l'interprétation qui fait la différence. Strictement parlant, il n'est pas défini:

    Un membre statique peut être appelée à l'aide de la classe membre de la syntaxe d'accès, auquel cas l'objet-l'expression est évaluée.

    C'est évaluée comme si c'étaient des non-statique, et nous avons encore une fois de déréférencer un pointeur null avec (*(E1)).E2.

    Cependant, parce que E1 n'est pas utilisé dans un membre statique-appel de la fonction, si nous utilisons la faiblesse de l'interprétation que l'appel est bien définie. *(E1) résultats dans une lvalue, la fonction statique est résolu, *(E1) est éliminé, et la fonction est appelée. Il n'y a pas de lvalue-à-rvalue de conversion, donc il n'y a pas de comportement indéfini.

    Dans C++0x, comme de n3126, l'ambiguïté demeure. Pour l'instant, d'être en sécurité: utilisation de l'interprétation stricte.

    • +1. La poursuite de la pédanterie, en vertu de la "faiblesse de la définition de" la fonction membre non statique n'a pas été appelée "pour un objet qui n'est pas de type X". Il a été appelé pour une lvalue qui n'est pas un objet. Donc, la solution proposée ajoute le texte "ou si la lvalue est vide lvalue" à l'article que vous citez.
    • Pourriez-vous préciser un peu? En particulier, avec votre "affaire réglée" et "actif " problème" des liens, quels sont les numéros d'édition? Aussi, si ce n'est une question fermée, quelle est exactement la réponse oui/non pour des fonctions statiques? J'ai l'impression que je vais manquer la dernière étape en essayant de comprendre votre réponse.
    • J'ai édité dans le numéro du clos-problème, le problème est le nombre trop. (Donner à la page un certain temps à charger donc votre navigateur pouvez sauter par-là, la page est énorme). La conclusion est que c'est correct, parce que la plus faible est de l'interprétation, le "accepté" de l'interprétation. (Que je vais ajouter.) J'lieu accepté par des guillemets car il n'est pas encore fermé.
    • Merci! C'est beaucoup plus clair. 🙂
    • Très intéressante. J'ai encore besoin de réfléchir à cela un peu plus, mais merci de ne pas laisser cette question se perdre. J'ai été déçu de voir le fil disparaître l'autre jour.
    • Pas de problème. Je pensais que c'était une bonne question.
    • Je ne pense pas que GTC défaut 315 est "fermée", comme sa présence sur les "questions fermées" page implique. La justification est dit qu'il devrait être autorisée, car "*p n'est pas une erreur lors de l' p est nul à moins que la lvalue est converti à une rvalue." Cependant, qui s'appuie sur le concept d'un "vide lvalue", qui fait partie de la proposition de résolution GTC défaut 232, mais qui n'a pas été adopté. Donc, avec la langue en C++03 et C++0x, le déréférencement de pointeur null est toujours pas défini, même si il n'y a pas de lvalue-à-rvalue de conversion.
    • J'ai édité, désolé, j'ai pris longtemps pour revenir à vous.
    • Selon ma compréhension, si p ont une adresse matérielle qui permettrait de déclencher une action lors de la lecture, mais n'ont pas été déclarées volatile, la déclaration *p; ne serait pas requis, mais il serait autorisé, de lire que l'adresse; la déclaration &(*p);, cependant, il serait interdit de le faire. Si *p ont été volatile, la lecture serait nécessaire. Dans les deux cas, si le pointeur n'est pas valide, je ne vois pas comment la première instruction ne serait pas un Comportement Indéfini, mais je ne vois pas pourquoi la deuxième déclaration serait.
    • convertit [*(E1) dans (*(E1)).E2] pour une rvalue". Pourquoi est l'objet de l'expression convertie à une rvalue? Je n'étais pas en mesure de trouver la règle.
    • ".E2 convertit en une rvalue, " - Euh, non, il n'est pas

    InformationsquelleAutor GManNickG
  2. 29

    Évidemment indéfini signifie qu'il est pas défini, mais parfois, il peut être prévisible. Les informations que je suis sur le point de fournir ne doivent jamais être invoqué pour code de travail, car il n'est pas garanti, mais il pourrait s'avérer utile lors du débogage.

    Vous pourriez penser que l'appel d'une fonction sur un objet pointeur de déréférencer le pointeur et causer de l'UB. Dans la pratique, si la fonction n'est pas virtuel, le compilateur ne l'avez converti à un simple appel de fonction en passant le pointeur en tant que premier paramètre ce, en contournant le déréférencement et la création d'une bombe à retardement pour les appelés de la fonction membre. Si la fonction de membre ne faisant pas référence à un membre quelconque de variables ou de fonctions virtuelles, il ne pourrait réussir sans erreur. Rappelez-vous que pour réussir relève de l'univers de "undefined"!

    De Microsoft MFC fonction GetSafeHwnd réellement s'appuie sur ce problème. Je ne sais pas ce qu'ils ont de fumer.

    Si vous êtes à l'appel d'une fonction virtuelle, le pointeur doit être déréférencé pour obtenir à la vtable, et pour sûr que vous allez obtenir UB (probablement un crash, mais rappelez-vous qu'il n'y a pas de garanties).

    • GetSafeHwnd d'abord fait un !cette case et si la valeur est true, retourne NULL. Puis il commence un SEH cadre et déréférence le pointeur. si il y a la Mémoire de Violation d'Accès (0xc0000005), c'est la pêche et de la valeur NULL est renvoyée à l'appelant 🙂 Sinon le HWND est retourné.
    • il a été quelques années depuis que j'ai regardé le code pour GetSafeHwnd, il est possible que ce qu'ils ont amélioré depuis. Et n'oubliez pas qu'ils ont connaissance d'initié sur le compilateur de fonctionnement!
    • Je suis indiquant un exemple possible de mise en œuvre qui ont le même effet, que faut-il vraiment faire est d'être à l'ingénierie inverse à l'aide d'un débogueur 🙂
    • "ils ont connaissance d'initié sur le compilateur de fonctionnement!" - la cause de l'éternelle difficulté pour des projets tels que MinGW qui tentent de permettre à g++ pour compiler le code qui appelle l'API Windows
    • Je pense que nous sommes tous d'accord c'est injuste. Et à cause de cela, je pense aussi qu'il y est une loi de la compatibilité qui en fait un tout petit peu illégal de le garder ainsi.
    • Merci de voir stackoverflow.com/questions/47026061/...
    • En particulier, la référence à la C++ FAQ cs.technion.ac.il/utilisateurs/yechiel/c++-faq/dyn-binding.html, il indique: "le compilateur résout non-fonctions virtuelles exclusivement au moment de la compilation en fonction du type du pointeur"

    InformationsquelleAutor Mark Ransom