En C, NULL est une constante symbolique qui pointe toujours vers un point inexistant de la mémoire. Bien que de nombreux programmeurs le considèrent comme égal à 0, il s'agit d'une simplification qui peut vous faire trébucher plus tard. Il est préférable de vérifier vos pointeurs directement par rapport à NULL et d'utiliser 0 dans d'autres contextes. Cela garde votre code propre et facile à comprendre, puisque vous saurez que vous travaillez avec des pointeurs chaque fois que vous voyez NULL.
Pas
Partie 1 sur 2: Exécution d'une vérification nulle
Étape 1. Utilisez le code de vérification nul standard
Ce qui suit est le moyen le plus évident d'écrire une vérification nulle. nous utiliserons ptr dans cet article comme nom du pointeur que vous vérifiez.
-
if(ptr == NULL)
{
// code si le pointeur est NULL
} autre {
// code si non NULL
}
Étape 2. Testez n'importe quelle valeur sauf NULL
Parfois, il est plus pratique de tester l'inégalité à la place. Pas de surprise ici:
-
if (ptr != NULL) {
// code si non NULL
}
Étape 3. Écrivez d'abord le NULL pour éviter les erreurs (facultatif)
Le principal inconvénient de la méthode PTR == NULL est le risque que vous tapiez accidentellement ptr = NULL à la place, en attribuant la valeur NULL à ce pointeur. Cela peut causer un mal de tête important. Étant donné que le test d'(in)égalité traite les opérandes de manière symétrique, vous pouvez obtenir exactement le même résultat en écrivant si (NULL == ptr) au lieu. Ceci est plus résistant aux fautes de frappe, car un NULL accidentel = ptr crée une simple erreur de compilation.
Cela semble un peu gênant pour certains programmeurs, mais c'est parfaitement valable. L'approche que vous utilisez dépend uniquement de vos préférences personnelles et de la capacité de votre compilateur à détecter l'erreur if (ptr = NULL)
Étape 4. Testez si la variable est vraie
Un simple si (ptr) teste si ptr est VRAI. Il renverra FALSE si ptr vaut NULL, ou si ptr vaut 0. La distinction n'a pas d'importance dans de nombreux cas, mais sachez que ceux-ci ne sont pas identiques dans toutes les architectures.
L'inverse est si (!ptr), qui retournera TRUE si ptr est FALSE.
Partie 2 sur 2: Éviter les erreurs
Étape 1. Définissez un pointeur avant de rechercher NULL
Une erreur courante consiste à supposer qu'un pointeur nouvellement créé a une valeur NULL. Ce n'est pas vrai. Un pointeur non affecté pointe toujours vers une adresse mémoire, mais pas celle que vous avez spécifiée. Il est courant de définir les pointeurs nouvellement créés ou nouvellement libérés sur NULL pour s'assurer que vous n'utilisez pas cette adresse inutile par accident.
-
Evitez cette erreur:
caractère *ptr;
if(ptr == NULL)
{
//Cela renverra FALSE. Le pointeur a reçu une valeur valide.
}
-
Écrivez plutôt:
char *ptr = NULL; // Ceci affecte le pointeur à NULL
if(ptr == NULL)
{
//Cela retournera TRUE si le pointeur n'a pas été réaffecté.
}
Étape 2. Faites attention aux fonctions qui pourraient renvoyer NULL
Si une fonction peut renvoyer NULL, demandez-vous si c'est une possibilité et si cela causerait des problèmes plus tard dans votre code. Voici un exemple de la fonction malloc utilisant la vérification null (si (ptr)) pour s'assurer qu'il ne gère que les pointeurs avec des valeurs valides:
-
int *ptr = malloc(N * sizeof(int));
si (ptr) {
int je;
pour (i = 0; i < N; ++i)
ptr = je;
}
Étape 3. Comprenez que NULL est 0 mais vous devez toujours utiliser NULL au lieu de 0 lorsque vous travaillez avec des pointeurs pour plus de clarté
Historiquement, C représentait NULL comme le nombre 0 (c'est-à-dire 0x00). De nos jours, cela peut devenir un peu plus compliqué et varie selon le système d'exploitation. Vous pouvez généralement vérifier NULL en utilisant ptr == 0, mais dans certains cas, cela peut poser problème. Peut-être plus important encore, l'utilisation de NULL montre clairement que vous travaillez avec des pointeurs pour d'autres personnes lisant votre code.
