Pointeurs nuls

Fait partie de la section Logique et Flux du Journey C++ de Coddy — leçon 4 sur 56.

Lorsque vous déclarez un pointeur, il ne pointe pas automatiquement vers quelque chose de significatif. Un pointeur non initialisé contient des adresses mémoire aléatoires, ce qui peut entraîner des erreurs graves si vous essayez de l'utiliser. C'est là que les pointeurs nuls deviennent essentiels pour une programmation sûre.

Un pointeur nul est un pointeur qui pointe explicitement vers rien. En C++ moderne, vous créez un pointeur nul en l'initialisant avec nullptr :

int* ptr = nullptr;  // ptr est maintenant un pointeur nul

Le mot-clé nullptr indique que le pointeur ne pointe vers aucun emplacement mémoire valide. C'est beaucoup plus sûr que de laisser un pointeur non initialisé, car vous pouvez vérifier si un pointeur est nul avant de tenter de le déréférencer.

Avant d'utiliser un pointeur, vous devriez vérifier qu'il n'est pas nul à l'aide d'une simple instruction if :

if (ptr != nullptr) {
    // Utilisation sûre de *ptr ici
    int value = *ptr;
}

Cette pratique empêche votre programme de planter en raison de l'accès à des emplacements mémoire invalides. Initialisez toujours les pointeurs à nullptr lorsque vous les déclarez, et vérifiez s'ils sont nuls avant de les déréférencer.

Défi

Facile

Créez un programme qui démontre l'utilisation sécurisée des pointeurs en vérifiant les pointeurs nuls avant de les déréférencer.

L'entrée suivante sera fournie :

Une chaîne de caractères qui sera soit "valid" soit "null"

Votre programme doit :

Déclarer une variable entière nommée data et l'initialiser avec la valeur 42
Déclarer un pointeur nommé ptr
Si l'entrée est "valid", assigner l'adresse de data à ptr
Si l'entrée est "null", assigner nullptr à ptr
Utiliser une instruction if pour vérifier si ptr n'est pas nul avant de tenter de l'utiliser
Si le pointeur n'est pas nul, afficher la valeur vers laquelle il pointe
Si le pointeur est nul, afficher un message de sécurité

Utilisez le format de sortie exact suivant :

Value: [value]

Pour les pointeurs nuls, utilisez ce format :

Pointer is null - cannot dereference

Aide-mémoire

Initialisez les pointeurs sur nullptr pour éviter un comportement indéfini :

int* ptr = nullptr;  // ptr est maintenant un pointeur nul

Vérifiez toujours si un pointeur n'est pas nul avant de le déréférencer :

if (ptr != nullptr) {
    // Utilisation sûre de *ptr ici
    int value = *ptr;
}

Le mot-clé nullptr indique explicitement que le pointeur ne pointe vers aucun emplacement mémoire valide, rendant votre code plus sûr et évitant les plantages dus à l'accès à une mémoire non valide.

Essayez vous-même

#include <iostream>
#include <string>
using namespace std;

int main() {
    // Lire l'entrée
    string input;
    cin >> input;
    
    // Déclarer la variable data
    int data = 42;
    
    // TODO : Écrivez votre code ici
    // - Déclarer un pointeur nommé ptr
    // - Vérifier l'entrée et assigner la valeur appropriée à ptr
    // - Utiliser une instruction if pour vérifier et utiliser le pointeur en toute sécurité
    
    return 0;
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique et Flux

3Projet : Outil de liste de tâches

Présentation du projet Ajouter une tâche

Afficher les tâches

Supprimer une tâche

Finaliser l'outil

6Ensembles (Éléments uniques)

Introduction à std::set Créer un Set et ajouter des éléments Vérifier la présence d'éléments Supprimer des éléments Parcourir un Set Récapitulatif - Nombres uniques

9Défis finaux

Filtrage de données de vecteur Recherche de valeur dans une Map Pointeur et tableau dynamique