Comment vérifions-nous si un pointeur est un pointeur NULL?

Question

Je pense toujours simplement que if(p != NULL){..} fera l'affaire. Mais après avoir lu cette question sur Stack Overflow, il semble que non.

Alors quelle est la manière canonique de vérifier les pointeurs NULL après avoir absorbé toute la discussion de cette question qui dit que les pointeurs NULL peuvent avoir une valeur non nulle?

Answer 1

Je pense toujours simplement que si (p != NULL){..} fera l'affaire.

Ça le fera.

Answer 2

En premier lieu, pour être 100% clair, il n'y a aucune différence entre C et C++ ici. Et deuxièmement, la question Stack Overflow que vous citez ne parle pas des pointeurs nuls; elle introduit des pointeurs non valides; des pointeurs qui, du moins selon le standard, provoquent un comportement indéfini juste en essayant de les comparer. Il n'y a pas moyen de tester en général si un pointeur est valide.

En fin de compte, il existe trois façons courantes de vérifier un pointeur nul :

if ( p != NULL ) ...

if ( p != 0 ) ...

if ( p ) ...

Tous fonctionnent, peu importe la représentation d'un pointeur nul sur la machine. Et tous, d'une manière ou d'une autre, sont trompeurs; lequel vous choisissez est une question de choisir le moins mauvais. Formellement, les deux premiers sont identiques pour le compilateur; la constante NULL ou 0 est convertie en un pointeur nul du type de p, et les résultats de la conversion sont comparés à p. Peu importe la représentation d'un pointeur nul.

Le troisième est légèrement différent : p est implicitement converti en bool. Mais la conversion implicite est définie comme les résultats de p != 0, donc vous finissez avec la même chose. (Ce qui signifie qu'il n'y a vraiment aucun argument valable pour utiliser le troisième style - cela obscurcit avec une conversion implicite, sans aucun bénéfice compensatoire.)

Lequel des deux premiers vous préférez est largement une question de style, peut-être partiellement dictée par votre style de programmation ailleurs : en fonction de l'idiome en question, l'un des mensonges sera plus gênant que l'autre. S'il ne s'agissait que d'une question de comparaison, je pense que la plupart des gens préféreraient NULL, mais dans quelque chose comme f( NULL ), le surcharge qui sera choisie est f( int ), et non une surcharge avec un pointeur. De même, si f est un modèle de fonction, f( NULL ) va instancier le modèle sur int. (Bien sûr, certains compilateurs, comme g++, généreront un avertissement si NULL est utilisé dans un contexte non-pointeur ; si vous utilisez g++, vous devriez vraiment utiliser NULL.)

Dans C++11, bien sûr, l'idiome préféré est :

if ( p != nullptr ) ...

, ce qui évite la plupart des problèmes avec les autres solutions. (Mais cela n'est pas compatible avec C:-).)

Answer 3

Le compilateur doit fournir un système de type cohérent et fournir un ensemble de conversions standard. Ni la valeur entière 0 ni le pointeur NULL n'ont besoin d'être représentés par des bits entièrement nuls, mais le compilateur doit se charger de convertir le token "0" du fichier d'entrée en la représentation correcte de zéro entier, et la conversion en type pointeur doit convertir de la représentation entière à la représentation pointeur.

L'implication de ceci est que

void *p;
memset(&p, 0, sizeof p);
if(p) { ... }

n'est pas garanti de se comporter de la même manière sur tous les systèmes cibles, car vous faites une hypothèse sur le motif binaire ici.

Par exemple, j'ai une plate-forme embarquée qui n'a pas de protection de mémoire et garde les vecteurs d'interruption à l'adresse 0, donc par convention, les entiers et les pointeurs sont XORés avec 0x2000000 lorsqu'ils sont convertis, ce qui laisse (void *)0 pointant vers une adresse qui génère une erreur de bus lorsqu'elle est déréférencée, cependant tester le pointeur avec une instruction if le renverra d'abord à une représentation entière, qui est alors entièrement nulle.

Answer 4

La représentation réelle d'un pointeur nul est sans importance ici. Un littéral entier avec une valeur nulle (y compris 0 et toute définition valide de NULL) peut être converti en tout type de pointeur, donnant un pointeur nul, quelle que soit la représentation réelle. Donc p != NULL, p != 0 et p sont tous des tests valides pour un pointeur non nul.

Vous pourriez rencontrer des problèmes avec des représentations non nulles du pointeur nul si vous écriviez quelque chose d'embrouillé comme p != reinterpret_cast(0), donc ne faites pas ça.

Je viens de remarquer que votre question est étiquetée C ainsi que C++. Ma réponse fait référence à C++, et d'autres langages peuvent être différents. Quel langage utilisez-vous?

Answer 5

Apparemment, le fil de discussion auquel vous faites référence concerne le C++.

En C, votre extrait de code fonctionnera toujours. J'aime le if (p) { /* ... */ } plus simple.