nullptr (C++/CLI e C++/CX)
La nullptr parola chiave rappresenta un valore puntatore Null. Usare un valore di puntatore Null per indicare che un handle di oggetto, un puntatore interno o un tipo di puntatore nativo non punta a un oggetto.
Usare nullptr con codice gestito o nativo. Il compilatore genera istruzioni appropriate ma diverse per i valori di puntatore Null gestito e nativo. Per informazioni sull'uso della versione C++ standard ISO di questa parola chiave, vedere nullptr.
La parola chiave __nullptr è una parola chiave specifica di Microsoft che ha lo stesso significato di nullptr, ma si applica solo al codice nativo. Se si usa nullptr con codice C/C++ nativo e quindi si esegue la compilazione con l'opzione del compilatore /clr , il compilatore non può determinare se nullptr indica un valore puntatore Null nativo o gestito. Per chiarire l'intenzione al compilatore, usare nullptr per specificare un valore gestito o __nullptr per specificare un valore nativo.
La nullptr parola chiave equivale a Nothing in Visual Basic e null in C#.
Utilizzo
La nullptr parola chiave può essere usata ovunque sia possibile usare un handle, un puntatore nativo o un argomento di funzione.
La nullptr parola chiave non è un tipo e non è supportata per l'uso con:
La nullptr parola chiave può essere usata nell'inizializzazione dei tipi di puntatore seguenti:
Puntatore nativo
Handle di Windows Runtime
Handle gestito
Puntatore interno gestito
La nullptr parola chiave può essere usata per verificare se un puntatore o un riferimento handle è Null prima che venga usato il riferimento.
Le chiamate di funzione tra linguaggi che usano valori di puntatore Null per il controllo degli errori devono essere interpretate correttamente.
Non è possibile inizializzare un handle su zero; può essere utilizzato solo nullptr . L'assegnazione di una costante 0 a un handle di oggetto produce un valore Int32 boxed e un cast a Object^.
Esempio: nullptr parola chiave
Nell'esempio di codice seguente viene illustrato che la nullptr parola chiave può essere usata ovunque sia possibile usare un handle, un puntatore nativo o un argomento di funzione. L'esempio dimostra che la nullptr parola chiave può essere usata per controllare un riferimento prima che venga usato.
// 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 ^)
}
Esempio: Usare nullptr e zero in modo intercambiabile
L'esempio di codice seguente mostra che nullptr e zero possono essere usati in modo intercambiabile nei puntatori nativi.
// 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
Esempio: interpretare nullptr come handle
Nell'esempio di codice seguente viene illustrato che nullptr viene interpretato come handle per qualsiasi tipo o puntatore nativo a qualsiasi tipo. Nel caso di overload di funzioni con handle a tipi diversi, verrà generato un errore di ambiguità. L'oggetto nullptr deve essere eseguito in modo esplicito a un tipo.
// 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);
}
Esempio: Cast nullptr
L'esempio di codice seguente mostra che il cast nullptr è consentito e restituisce un puntatore o un handle al tipo di cast che contiene il nullptr valore.
// 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)
}
Esempio: Passare nullptr come parametro di funzione
L'esempio di codice seguente mostra che nullptr può essere usato come parametro di funzione.
// mcpp_nullptr_4.cpp
// compile with: /clr
using namespace System;
void f(Object ^ x) {
Console::WriteLine("test");
}
int main() {
f(nullptr);
}
test
Esempio: inizializzazione predefinita
Nell'esempio di codice seguente viene illustrato che, quando gli handle vengono dichiarati e non inizializzati in modo esplicito, vengono inizializzati per impostazione predefinita su 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
Esempio: Assegnare nullptr a un puntatore nativo
Nell'esempio di codice seguente viene illustrato che nullptr è possibile assegnare a un puntatore nativo quando si compila con /clr.
// mcpp_nullptr_6.cpp
// compile with: /clr
int main() {
int * i = 0;
int * j = nullptr;
}
Requisiti
Opzione del compilatore: (non richiesta; supportata da tutte le opzioni di generazione del codice, incluse /ZW e /clr)