nullptr (extensions du composant C++)
Le mot clé d' nullptr représente une valeur de pointeur null.Utilisez une valeur de pointeur null pour indiquer qu'un handle d'objet, un pointeur intérieur, ou un type pointeur natif n'indique pas un objet.
Utilisez nullptr avec managé ou natif.Les émet du compilateur approprié si mais des instructions pour les valeurs managées et natives de pointeur null.Pour plus d'informations sur l'utilisation de la version de la norme de l'OIN C++ de ce mot clé, consultez nullptr.
Le mot clé d' __nullptr est un mot clé spécifiques à microsoft qui a la même signification qu' nullptr, mais s'applique uniquement au code natif.Si vous utilisez nullptr avec le code natif C/C++ puis compilez avec l'option du compilateur de /clr , le compilateur ne peut pas déterminer si nullptr indique un natif ou une valeur managée de pointeur null.Pour rendre votre intention claire au compilateur, à l'aide nullptr de spécifier une valeur managée ou __nullptr pour spécifier une valeur native.
Le mot clé d' nullptr équivaut à Nothing en Visual Basic et à null en C#.
Utilisation
Le mot clé d' nullptr peut être utilisée n'importe où un handle, pointeur natif, ou l'argument de fonction peut être utilisé.
Le mot clé d' nullptr n'est pas un type et n'est pas pris en charge pour l'utiliser avec :
Le mot clé d' nullptr peut être utilisé dans l'initialisation des types pointeur suivants :
Pointeur natif
Handle d'exécution windows
Handle managé
Pointeur intérieur managé
Le mot clé d' nullptr peut être utilisé pour tester si une référence de type pointeur ou de handle est null avant que la référence est utilisée.
Des appels de fonction entre les langages qui utilisent des valeurs de type pointeur null pour la vérification des erreurs doivent être interprètes correctement.
Vous ne pouvez pas initialiser un handle à zéro ; uniquement nullptr peut être utilisé.L'assignation de la constante 0 à un handle d'objet génère Int32 boxed et un cast à Object^.
Exemple
L'exemple de code suivant montre que le mot clé d' nullptr peut être utilisé où un handle, pointeur natif, ou l'argument de fonction peut être utilisé.Et l'exemple montre que le mot clé d' nullptr peut être utilisé pour contrôler une référence avant qu'il soit 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
L'exemple de code suivant illustre cet nullptr et zéro peut être utilisé l'un à l'autre sur les 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");
}
Sortie
Exemple
L'exemple de code suivant montre qu' nullptr est interprète comme un handle à tout type ou à un pointeur natif à n'importe quel type.En cas de surcharge de fonction avec les handles de types différents, une erreur d'ambiguïté est générée.nullptr doit être explicitement castées en un 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
L'exemple de code suivant montre qu'il permet le cast d' nullptr et retourne un pointeur ou un handle vers le type de cast qui contient la valeur d' nullptr .
// 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
l'exemple de code suivant montre qu' nullptr peut être utilisé 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);
}
Sortie
Exemple
L'exemple de code suivant montre que lorsque les handles sont déclarés et pas explicitement, ils sont initialisés par défaut initialisée à 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();
}
Sortie
Exemple
L'exemple de code suivant montre qu' nullptr peut être assigné à un pointeur natif lorsque vous compilez avec /clr.
// mcpp_nullptr_6.cpp
// compile with: /clr
int main() {
int * i = 0;
int * j = nullptr;
}
Configuration requise
Option du compilateur : (Non requis ; pris en charge par toutes les options de génération du code, y compris /ZW et /clr)