Pointeurs null

Editer en ligne

Un pointeur NULL a une valeur réservée appelée constante de pointeur NULL pour indiquer que le pointeur ne pointe pas vers un objet ou une fonction valide. Vous pouvez utiliser des pointeurs null dans les cas suivants:

  • Initialisez les pointeurs.
  • Représenter des conditions telles que la fin d'une liste de longueur inconnue.
  • Indique des erreurs lors du renvoi d'un pointeur à partir d'une fonction.

Une constante de pointeur null est une expression de constante entière qui a pour résultat zéro. Par exemple, une constante de pointeur null peut être 0,0L, ou une expression de ce type qui peut être transtypée en type(void *)0. C++C++11 définit une nouvelle constante de pointeur nullnullptrqui ne peut être converti qu'en n'importe quel type de pointeur, type de pointeur vers membre ou type de bool.

Vous pouvez spécifier l'une des valeurs suivantes pour une constante de pointeur null:

  • 0
  • NULL
  • C++nullptr

Remarque: La valeur NULL est une macro. Il doit être défini avant utilisation.

Constantes de pointeur NULL

0 %

Vous pouvez utiliser une expression de constante entière avec la valeur 0 ou une expression convertie en(void *)0en tant que constante de pointeur null.

NULL

La macro NULL et la valeur 0 sont équivalentes à des constantes de pointeur null, mais NULL est plus propre car elle représente le but de l'utilisation de la constante pour un pointeur.

C++ Début de C++11 uniquement.

tr_nullptr

nullptrest une constante de pointeur null explicite. En C + +, l'initialisation des pointeurs null avec 0 ou NULL pose les problèmes suivants:

  • Il est impossible de faire la distinction entre un pointeur null et un entier 0 pour les fonctions surchargées. Par exemple, compte tenu de deux fonctions surchargéesf(int)etf(char*), l'appelf(0)est résolu enf(int)parce que0est converti en type intégral à la place du type pointeur. Voir Example1.
  • Une constante de pointeur null n'a pas de nom de type sécurisé. La macro NULL ne peut pas être distinguée de la0constante pour les fonctions surchargées et la détection des erreurs.

Pour résoudre les problèmes des constantes de pointeur null, C++11 a introduit un nouveau mot clénullptr. Lenullptrconstante peut être distinguée de l'entier 0 pour les fonctions surchargées. Voir l'exemple 2.

Une constante de pointeur null avec lenullptrLa valeur présente les caractéristiques suivantes:

  • Il peut être converti en n'importe quel type de pointeur ou de pointeur vers membre.
  • Il ne peut pas être converti implicitement en un autre type, à l'exception du type bool.
  • Il ne peut pas être utilisé dans une expression arithmétique.
  • Il peut être comparé à l'entier 0.
  • Il peut être utilisé dans des expressions relationnelles pour la comparaison avec des pointeurs ou des données de lastd::nullptr_t.

Voir l'exemple 3 pour plus d'informations sur l'utilisationnullptrcomme initialiseur pour tous les types de pointeur et dans les expressions de comparaison.

Remarque: Il est toujours acceptable d'affecter la valeur 0 ou NULL à un pointeur.

:NONE.nullptrkeyword désigne une valeur rvalue constante de typedecltype(nullptr). L'expression typedef esttypedef decltype(nullptr) nullptr_t, dont:nullptr_test une définition de type pourdecltype(nullptr)qui est défini dans<cstddef>. Un paramètre et un argument de modèle non-type peuvent avoir lestd::nullptr_t. Si un paramètre de modèle autre qu'un type est de typestd::nullptr_t, l'argument correspondant doit être de typestd::nullptr_t. Voir l'exemple 4. Si un paramètre de modèle de non-type est de l'un des types suivants, le type de l'argument de modèle de non-type correspondant peut êtrestd::nullptr_t. La conversion de pointeur null se produit pour les trois derniers types:

  • std::nullptr_t
  • pointeur
  • pointeur vers membre
  • booléen

Lorsque vous utiliseznullptrdans le traitement des exceptions, prêter attention à lathrowetcatchArguments. Un gestionnaire est une correspondance pour un objet d'exception de typeEsi le gestionnaire est de typecv Touconst T&.Test un type de pointeur ou de pointeur vers membre etEest de typestd::nullptr_t. Voir exemple 5.

Exemples

Exemple 1 : Cet exemple illustre une utilisation inappropriée de la constante NULL pour les fonctions surchargées:

#include <stdio.h>

void func(int* i){
   printf("func(int*)\n");
}

void func(int i){
   printf("func(int)\n");
}

int main(){
   func(NULL);
}

Supposons que vous souhaitiez que la fonction principale appellefunc(int* i). En conséquence, lamainappels de fonctionfunc(int i)Au lieu defunc(int* i)car la constante NULL est égale à l'entier 0. La constante 0 est implicitement convertie en(void*)0, uniquement lorsquefunc(int i)n'existe pas.

Exemple 2. Cet exemple illustre commentnullptrest utilisé dans les fonctions de surcharge:

void f( char* );
void f( int );
f( nullptr );     // calls f( char* )
f( 0 );           // calls f( int )

Exemple 3. Les expressions suivantes illustrent l'utilisation correcte et incorrecte dunullptrconstante:

char* p = nullptr;     // p has the null pointer value 
char* p1 = 0;          // p has the null pointer value 
int a = nullptr;       // error 
int a2 = 0;            // a2 is zero of integral type
if( p == 0 );          // evaluates to true 
if( p == nullptr );    // evaluates to true 
if( p );               // evaluates to false
if( a2 == 0 );         // evaluates to true 
if( a2 == nullptr );   // error, no conversion
if( nullptr );         // OK, conversion to the bool type 
if( nullptr == 0 );    // OK, comparison with 0
nullptr = 0;           // error, nullptr is not an lvalue 
nullptr + 2;           // error

Exemple 4. Cet exemple illustre le fait qu'un paramètre ou un argument de modèle non-type peut avoir la valeurstd::nullptr_tType :

typedef decltype(nullptr) nullptr_t;
template <nullptr_t> void fun1(); // non-type template parameter

fun1<nullptr>();      // non-type template arguments 
fun1<0>();            // error. The corresponding argument must be of type
                      // std::nullptr_t if the parameter is of type std::nullptr_t.

template <int* p> void fun2(); 
fun2<nullptr>();      //Correct

template<typename T> void h( T t );
h( 0 );                   // deduces T = int
h( nullptr );             // deduces T = nullptr_t
h( (float*) nullptr );    // deduces T = float*

Exemple 5. Cet exemple illustre comment utilisernullptrdans le traitement des exceptions:

int main() {
try {
   throw nullptr;
} catch(int* p) {  // match the pointer.
   return p == 0;
}
}

C++ Fin de C++11 uniquement.