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

Le nullptr mot clé représente une valeur de pointeur null.The nullptr keyword represents a null pointer value. 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.Use a null pointer value to indicate that an object handle, interior pointer, or native pointer type does not point to an object.

Utilisez nullptr avec le code managé ou natif.Use nullptr with either managed or native code. Le compilateur émet des instructions appropriées mais différentes pour les valeurs de pointeur null natives et managées.The compiler emits appropriate but different instructions for managed and native null pointer values. Pour plus d’informations sur l’utilisation de la version ISO C++ standard de ce mot clé, consultez nullptr.For information about using the ISO standard C++ version of this keyword, see nullptr.

Le mot clé __nullptr est un mot clé spécifique à Microsoft qui a la même signification que nullptr , mais s’applique uniquement au code natif.The __nullptr keyword is a Microsoft-specific keyword that has the same meaning as nullptr, but applies to only native code. Si vous utilisez nullptr avec du code C/C++ natif, puis compilez avec l’option de compilateur /CLR , le compilateur ne peut pas déterminer si nullptr indique une valeur de pointeur null native ou managée.If you use nullptr with native C/C++ code and then compile with the /clr compiler option, the compiler cannot determine whether nullptr indicates a native or managed null pointer value. Pour que votre intention soit claire pour le compilateur, utilisez nullptr pour spécifier une valeur managée ou __nullptr pour spécifier une valeur native.To make your intention clear to the compiler, use nullptr to specify a managed value or __nullptr to specify a native value.

Le nullptr mot clé est équivalent à Nothing dans Visual Basic et null en C#.The nullptr keyword is equivalent to Nothing in Visual Basic and null in C#.

UtilisationUsage

Le nullptr mot clé peut être utilisé partout où il est possible d’utiliser un handle, un pointeur natif ou un argument de fonction.The nullptr keyword can be used anywhere a handle, native pointer, or function argument can be used.

Le nullptr mot clé n’est pas un type et n’est pas pris en charge pour une utilisation avec :The nullptr keyword is not a type and is not supported for use with:

  • sizeofsizeof

  • TypeIdtypeid

  • throw nullptr (bien que throw (Object^)nullptr; fonctionne)throw nullptr (although throw (Object^)nullptr; will work)

Le nullptr mot clé peut être utilisé dans l’initialisation des types de pointeurs suivants :The nullptr keyword can be used in the initialization of the following pointer types:

  • Pointeur natifNative pointer

  • Descripteur Windows RuntimeWindows Runtime handle

  • Descripteur managéManaged handle

  • Pointeur intérieur managéManaged interior pointer

Le nullptr mot clé peut être utilisé pour tester si un pointeur ou une référence de handle a la valeur null avant que la référence soit utilisée.The nullptr keyword can be used to test if a pointer or handle reference is null before the reference is used.

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.Function calls among languages that use null pointer values for error checking should be interpreted correctly.

Vous ne pouvez pas initialiser un handle à zéro ; seul nullptr peut être utilisé.You cannot initialize a handle to zero; only nullptr can be used. L’affectation de la constante 0 pour un descripteur d’objet produit un Int32 boxed et effectue un cast dans Object^.Assignment of constant 0 to an object handle produces a boxed Int32 and a cast to Object^.

Exemple : nullptr mot cléExample: nullptr keyword

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é.The following code example demonstrates that the nullptr keyword can be used wherever a handle, native pointer, or function argument can be used. Et l’exemple montre que le nullptr mot clé peut être utilisé pour vérifier une référence avant son utilisation.And the example demonstrates that the nullptr keyword can be used to check a reference before it is used.

// 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 : utilisez nullptr et zéro de façon interchangeableExample: Use nullptr and zero interchangeably

L’exemple de code suivant montre que nullptr et zéro peut être utilisé de manière interchangeable sur des pointeurs natifs.The following code example shows that nullptr and zero can be used interchangeably on native pointers.

// 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 comme un handleExample: Interpret nullptr as a handle

L’exemple de code suivant montre que nullptr est interprété comme un handle de tout type ou un pointeur natif vers n’importe quel type.The following code example shows that nullptr is interpreted as a handle to any type or a native pointer to any 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.In case of function overloading with handles to different types, an ambiguity error will be generated. Doit nullptr être explicitement casté en type.The nullptr would have to be explicitly cast to a 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 nullptrExample: Cast nullptr

L’exemple de code suivant montre que la conversion nullptr est autorisée et retourne un pointeur ou un handle vers le type de cast qui contient la nullptr valeur.The following code example shows that casting nullptr is allowed and returns a pointer or handle to the cast type that contains the nullptr value.

// 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 : Pass nullptr en tant que paramètre de fonctionExample: Pass nullptr as a function parameter

L’exemple de code suivant montre que nullptr peut être utilisé comme paramètre de fonction.The following code example shows that nullptr can be used as a function parameter.

// 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éfautExample: Default initialization

L’exemple de code suivant montre que lorsque les handles sont déclarés et ne sont pas explicitement initialisés, ils sont initialisés par défaut à nullptr .The following code example shows that when handles are declared and not explicitly initialized, they are default initialized to 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 : assigner nullptr à un pointeur natifExample: Assign nullptr to a native pointer

L’exemple de code suivant montre qu' nullptr il est possible d’assigner à un pointeur natif quand vous compilez avec /clr .The following code example shows that nullptr can be assigned to a native pointer when you compile with /clr.

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

SpécificationsRequirements

Option du compilateur : (non obligatoire ; prise en charge par toutes les options de génération de code, y compris /ZW et /clr )Compiler option: (Not required; supported by all code generation options, including /ZW and /clr)

Voir aussiSee also

Extensions de composant pour .NET et UWPComponent Extensions for .NET and UWP
nullptrnullptr