nullptr (C++/CLI et C++/CX)
Le 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 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. 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é est équivalent à 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.
Le nullptr mot clé n’est pas un type et n’est pas pris en charge pour une utilisation avec :
Le nullptr mot clé peut être utilisé dans l’initialisation des types de pointeur suivants :
Pointeur natif
Descripteur Windows Runtime
Descripteur managé
Pointeur intérieur managé
Le nullptr mot clé peut être utilisé pour tester si un pointeur ou une référence 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 vérifier une référence avant d’être utilisé.
// 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)