nullptr (C++/CLI et C++/CX)

  • Article

La nullptr mot clé représente une valeur de pointeur Null. Utilisez une valeur de pointeur null pour indiquer qu’un descripteur d’objet, un pointeur intérieur ou un type de pointeur natif ne pointent pas vers un objet.

Utiliser nullptr avec du code managé ou natif. Le compilateur émet des instructions appropriées mais différentes pour les valeurs de pointeur null natives et managées. Pour plus d’informations sur l’utilisation de la version ISO C++ standard de ce mot clé, consultez nullptr.

Le __nullptr mot clé est un mot clé spécifique à Microsoft qui a la même signification que nullptr, mais s’applique uniquement au code natif. Si vous utilisez nullptr du code C/C++ natif, puis compilez avec l’option du compilateur /clr , le compilateur ne peut pas déterminer si nullptr une valeur de pointeur Null native ou gérée est spécifiée. Pour clarifier votre intention au compilateur, utilisez nullptr pour spécifier une valeur managée ou __nullptr pour spécifier une valeur native.

Le nullptr mot clé équivaut à Nothing en Visual Basic et null en C#.

Utilisation

Le nullptr mot clé peut être utilisé n’importe où un handle, un pointeur natif ou un argument de fonction peut être utilisé.

Le nullptr mot clé n’est pas un type et n’est pas pris en charge pour une utilisation avec :

  • sizeof

  • typeid

  • throw nullptr (bien que throw (Object^)nullptr; fonctionne)

Le nullptr mot clé peut être utilisé dans l’initialisation des types de pointeurs suivants :

  • Pointeur natif

  • Descripteur Windows Runtime

  • Descripteur managé

  • Pointeur intérieur managé

La nullptr mot clé peut être utilisée pour tester si une référence de pointeur ou de handle est null avant l’utilisation de la référence.

Les appels de fonction dans les langages qui utilisent des valeurs de pointeur null pour la vérification des erreurs doivent être interprétés correctement.

Vous ne pouvez pas initialiser un handle à zéro ; ne peut être utilisé que nullptr . L’affectation de la constante 0 pour un descripteur d’objet produit un Int32 boxed et effectue un cast dans Object^.

Exemple : nullptr mot clé

L’exemple de code suivant montre que le nullptr mot clé peut être utilisé partout où un handle, un pointeur natif ou un argument de fonction peut être utilisé. Et l’exemple montre que le nullptr mot clé peut être utilisé pour case activée une référence avant d’être utilisée.

// mcpp_nullptr.cpp
// compile with: /clr
value class V {};
ref class G {};
void f(System::Object ^) {}

int main() {
// Native pointer.
   int *pN = nullptr;
// Managed handle.
   G ^pG = nullptr;
   V ^pV1 = nullptr;
// Managed interior pointer.
   interior_ptr<V> pV2 = nullptr;
// Reference checking before using a pointer.
   if (pN == nullptr) {}
   if (pG == nullptr) {}
   if (pV1 == nullptr) {}
   if (pV2 == nullptr) {}
// nullptr can be used as a function argument.
   f(nullptr);   // calls f(System::Object ^)
}

Exemple : Utiliser nullptr et zéro indifféremment

L’exemple de code suivant montre que nullptr et zéro peuvent être utilisés de façon interchangeable sur des pointeurs natifs.

// mcpp_nullptr_1.cpp
// compile with: /clr
class MyClass {
public:
   int i;
};

int main() {
   MyClass * pMyClass = nullptr;
   if ( pMyClass == nullptr)
      System::Console::WriteLine("pMyClass == nullptr");

   if ( pMyClass == 0)
      System::Console::WriteLine("pMyClass == 0");

   pMyClass = 0;
   if ( pMyClass == nullptr)
      System::Console::WriteLine("pMyClass == nullptr");

   if ( pMyClass == 0)
      System::Console::WriteLine("pMyClass == 0");
}

pMyClass == nullptr

pMyClass == 0

pMyClass == nullptr

pMyClass == 0

Exemple : Interpréter nullptr en tant que handle

L’exemple de code suivant montre qu’il nullptr s’agit d’un handle vers n’importe quel type ou d’un pointeur natif vers n’importe quel type. En cas de surcharge de fonction avec des descripteurs vers des types différents, une erreur d’ambiguïté sera générée. Il nullptr faudrait effectuer une conversion explicite en type.

// mcpp_nullptr_2.cpp
// compile with: /clr /LD
void f(int *){}
void f(int ^){}

void f_null() {
   f(nullptr);   // C2668
   // try one of the following lines instead
   f((int *) nullptr);
   f((int ^) nullptr);
}

Exemple : Cast nullptr

L’exemple de code suivant montre que le cast nullptr est autorisé et retourne un pointeur ou un handle vers le type de cast qui contient la nullptr valeur.

// mcpp_nullptr_3.cpp
// compile with: /clr /LD
using namespace System;
template <typename T>
void f(T) {}   // C2036 cannot deduce template type because nullptr can be any type

int main() {
   f((Object ^) nullptr);   // T = Object^, call f(Object ^)

   // Delete the following line to resolve.
   f(nullptr);

   f(0);   // T = int, call f(int)
}

Exemple : Passer nullptr en tant que paramètre de fonction

L’exemple de code suivant montre que nullptr vous pouvez utiliser comme paramètre de fonction.

// mcpp_nullptr_4.cpp
// compile with: /clr
using namespace System;
void f(Object ^ x) {
   Console::WriteLine("test");
}

int main() {
   f(nullptr);
}

test

Exemple : initialisation par défaut

L’exemple de code suivant montre que lorsque les handles sont déclarés et non explicitement initialisés, ils sont initialisés par défaut sur nullptr.

// mcpp_nullptr_5.cpp
// compile with: /clr
using namespace System;
ref class MyClass {
public:
   void Test() {
      MyClass ^pMyClass;   // gc type
      if (pMyClass == nullptr)
         Console::WriteLine("NULL");
   }
};

int main() {
   MyClass ^ x = gcnew MyClass();
   x -> Test();
}

NULL

Exemple : Affecter nullptr à un pointeur natif

L’exemple de code suivant montre qu’il est possible d’attribuer nullptr un pointeur natif lorsque vous compilez avec /clr.

// mcpp_nullptr_6.cpp
// compile with: /clr
int main() {
   int * i = 0;
   int * j = nullptr;
}

Spécifications

Option du compilateur : (Non obligatoire ; prise en charge par toutes les options de génération de code, y compris /ZW et /clr)

Voir aussi

Extensions de composants pour .NET et UWP
nullptr