web-dev-qa-db-fra.com

Comment vérifier si le pointeur vide indique NULL?

Donc si vous le faites:

void *ptr = NULL;

Quel est le meilleur moyen de vérifier si ce pointeur vide est NULL?

Ma solution pour l'instant est la suivante:

if (*(void**)ptr == NULL) ...

Mais cela ne semble pas être la meilleure solution, car je suppose implicitement que ptr est de type void ** (ce qui n’est pas le cas).

cpointersvoid-pointers
7
pyrrhic

J'écrirais simplement if (!ptr).

NULL est fondamentalement juste 0 et !0 est vrai.

11
nmaier

Assurez-vous d'inclure une définition de NULL.

   #include <stddef.h>

   void  *X = NULL;

   // do stuff

   if (X != NULL)  // etc.

Si vous incluez <stdio.h> et similaire, alors stddef.h est automatiquement intégré.

Enfin, il est intéressant de regarder la définition de NULL dans stddef.h et, ce faisant, vous verrez pourquoi votre première idée de ce qu'il faut faire est intéressante.

6
JackCColeman

Un pointeur NULL est un pointeur qui ne pointe nulle part. Sa valeur est généralement définie dans stddef.h comme suit:

#define NULL ((void*) 0)

ou

#define NULL 0

Puisque NULL est égal à zéro, une instruction if pour vérifier si un pointeur est NULL vérifie si ce pointeur est à zéro. Par conséquent, if (ptr) est évalué à 1 lorsque le pointeur n'est pas NULL et inversement, if (!ptr) est évalué à 1 lorsque le pointeur est NULL. 

Votre approche if (*(void**)ptr == NULL) convertit le pointeur void en un pointeur vers un pointeur, puis tente de le déréférencer. Un pointeur point à point déréférencé génère un pointeur. Cela peut donc sembler une approche valide. Cependant, étant donné que ptr est NULL, lorsque vous la déréférence, vous invoquez un comportement non défini. 

Il est beaucoup plus simple de vérifier if (ptr == NULL) ou, en utilisant la notation abrégée, if (!ptr). 

2
verbose

Si votre code parvient à se compiler lors de l'affectation de void *ptr = NULL, il va sans dire qu'une simple instruction if pour comparer si elle est NULL devrait suffire, en particulier parce que NULL devrait être défini si le code peut être compilé.

Exemple de moyen suffisant pour vérifier:

if(ptr==NULL)
{
    rest of code...
}

J'ai écrit un petit programme de test, compilé avec gcc sur linux, qui fonctionne:

int main()
{
    void *ptr = NULL;
    if(ptr==NULL)
    {
        return 1;
    }
    return 0;
}
1
xt454

Je sais que ceci est un peu ancien, mais je voulais ajouter quelque chose qui pourrait être utile.

Ce que je fais habituellement est quelque chose comme ça,

Ceci est ma fonction.

void MyMethod(  const void* l_pData  ///< Source data
              , size_t l_nLen        /**< Number of bytes to convert */) {
    // Return if nothing is provided
    if (l_pData == NULL || ((const char*)(l_pData))[0] == '\0' || 0 == l_nLen) {
        return;
    }

    // Rest of the code
}

Vous pouvez vérifier

 - Null data
 - Empty data
 - Invalid length

Les suivants sont validés

MyMethod("", 10);
MyMethod(" ", 10);
MyMethod(NULL, 10);
MyMethod("valid", 0);
0
SajithP