0Pricing
C++ Academy · Leçon

nullptr et sécurité des pointeurs nuls

Utiliser nullptr plutôt que NULL ou 0 et se protéger contre les déréférencements nuls

nullptr et sécurité des pointeurs nuls est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Qu’est-ce qu’un pointeur nul

Un pointeur nul est une valeur spéciale qui pointe vers « rien ». Le déréférencer entraîne un comportement indéfini — généralement un plantage avec une erreur de segmentation.

nullptr en C++ moderne

Depuis C++11, le mot-clé nullptr représente un littéral de pointeur nul typé. Préférez-le à NULL ou 0.

int* p1 = nullptr;
int* p2 = NULL;       // legacy macro
int* p3 = 0;          // legacy literal

Pourquoi nullptr

NULL n’est qu’une macro pour 0. Elle peut perturber la résolution de surcharge entre int et int*. nullptr possède le type unique std::nullptr_t.

void f(int);
void f(int*);

f(NULL);      // calls f(int) -- surprising!
f(nullptr);   // calls f(int*) -- correct

Vérifier la nullité

Les pointeurs se convertissent implicitement en bool : un pointeur non nul vaut true et un pointeur nul vaut false.

if (p) std::cout << "has value\n";
if (!p) std::cout << "is null\n";
if (p != nullptr) std::cout << "explicit form\n";

Toujours initialiser

Les pointeurs non initialisés contiennent des valeurs arbitraires et donnent l’impression de pointer quelque part. Initialisez-les toujours, même si c’est simplement avec nullptr.

int* p;            // BAD: undefined contents
int* q = nullptr;  // GOOD

Déréférencer un pointeur nul

Lire ou écrire via un pointeur nul entraîne un comportement indéfini. Sur la plupart des systèmes de bureau, cela provoque une erreur de segmentation. Sur les appareils embarqués, cela peut corrompre la mémoire silencieusement.

Vérifications défensives

Vérifiez la valeur avant de déréférencer dans les API publiques ou lorsque l’appelant peut transmettre une valeur nulle.

void process(int* data) {
    if (!data) return;
    *data *= 2;
}

Références plutôt que pointeurs

Si la valeur nulle n’a jamais de sens, utilisez un paramètre de référence. Le compilateur garantit que la référence est liée à un objet.

// Before
void f(Widget* w);   // can be null?

// After
void f(Widget& w);   // must be a real widget

std::optional pour les valeurs facultatives

C++17 a ajouté std::optional<T> pour représenter « peut-être une valeur » — c’est plus clair qu’un pointeur nullable dans les contextes sans allocation.

#include <optional>
std::optional<int> find(int x);
if (auto v = find(42)) std::cout << *v;

Pointeurs intelligents et nullité

std::unique_ptr et std::shared_ptr peuvent également être nuls. Ils se convertissent en bool pour les vérifications et se réinitialisent avec = nullptr.

Piège : pointeur pendant après delete

Après delete p, le pointeur contient toujours l’ancienne adresse. Réinitialisez-le : p = nullptr;. Les pointeurs intelligents le font automatiquement.

Vérification rapide

Quel littéral de pointeur nul devez-vous utiliser en C++ moderne ?

Récapitulatif

Utilisez nullptr pour les valeurs de pointeur nul. Initialisez toujours les pointeurs. Vérifiez la valeur avant de déréférencer ou, mieux encore, utilisez des références et std::optional lorsque la valeur nulle n’est jamais valide.

Questions Fréquemment Posées

La leçon « nullptr et sécurité des pointeurs nuls » est-elle gratuite ?

Oui — le texte complet de « nullptr et sécurité des pointeurs nuls » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « nullptr et sécurité des pointeurs nuls » ?

Utiliser nullptr plutôt que NULL ou 0 et se protéger contre les déréférencements nuls Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « nullptr et sécurité des pointeurs nuls » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pointeurs bruts et opérateur d’adresse
  2. Déréférencement et arithmétique des pointeurs
  3. nullptr et sécurité des pointeurs nuls
  4. Quand utiliser des pointeurs ou des références
← Retour à C++ Academy