nullptr (Estensioni del componente C++)
La parola chiave nullptr rappresenta un valore del puntatore NULL.Utilizzare un valore del puntatore NULL per indicare che un handle dell'oggetto, un puntatore interno, o un tipo puntatore nativo non indicano un oggetto.
Utilizzare nullptr con gestito o nativo.Il compilatore genera istruzioni appropriate ma diversi per i valori di puntatore null gestite e native.Per informazioni sulla versione dello standard ISO C++ di questa parola chiave, vedere nullptr.
La parola chiave __nullptr è una parola chiave in specifica che ha lo stesso significato nullptr, ma si applica solo al codice nativo.Se si utilizza nullptr con il codice nativo C/C++ quindi compilate con l'opzione del compilatore /clr, il compilatore non può determinare se nullptr indica un nativo o un valore del puntatore NULL gestito.Per eseguire la cancellazione di intenzioni, utilizzare nullptr per specificare un valore gestito o __nullptr per specificare un valore nativo.
La parola chiave nullptr equivale a Nothing in Visual Basic e a null in C#.
Utilizzo
La parola chiave nullptr può essere utilizzata ovunque l'handle, puntatore nativo, o argomento di funzione può essere utilizzato.
La parola chiave nullptr non è un tipo e non è supportata per l'utilizzo con:
La parola chiave nullptr può essere utilizzata nell'inizializzazione dei seguenti tipi di puntatore:
Puntatore nativo
Handle di Windows Runtime
Handle gestite
Puntatore interno gestito
La parola chiave nullptr può essere utilizzata per verificare se un riferimento di handle o del puntatore è null prima che il riferimento sia utilizzato.
Le chiamate di funzione tra i linguaggi che utilizzano i valori di puntatore null per il controllo degli errori dovrebbero essere interpretate correttamente.
Non è possibile inizializzare un handle a zero, solo nullptr può essere utilizzato.L'assegnazione della costante 0 a un oggetto produce Int32 boxed e un cast a Object^.
Esempio
Nell'esempio di codice viene illustrato che la parola chiave nullptr può essere utilizzata ovunque sia l'handle, puntatore nativo, o argomento di funzione può essere utilizzato.E viene dimostrato che la parola chiave nullptr può essere utilizzata per controllare un riferimento prima che venga utilizzata.
// 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
Il seguente esempio di codice viene illustrata tale nullptr e zero è possibile utilizzare indifferentemente sui 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");
}
Output
Esempio
Nell'esempio di codice viene illustrato che nullptr viene interpretata come un handle a qualsiasi tipo o a un puntatore nativo a qualsiasi tipo.Nel caso dell'overload di funzione con un handle per diversi tipi, un errore di ambiguità verrà generata un'eccezione.nullptr in modo esplicito eseguire il cast su 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
Nell'esempio di codice viene illustrato che eseguire il cast nullptr è consentito e restituisce un puntatore o un handle per il tipo di cast contenente il valore 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)
}
Esempio
Nell'esempio di codice viene illustrato che nullptr può essere utilizzato come parametro della funzione.
// mcpp_nullptr_4.cpp
// compile with: /clr
using namespace System;
void f(Object ^ x) {
Console::WriteLine("test");
}
int main() {
f(nullptr);
}
Output
Esempio
Nell'esempio di codice viene illustrato che quando l'handle sono dichiarate e non vengono inizializzate, vengono impostazione predefinita inizializzata a 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();
}
Output
Esempio
Nell'esempio di codice viene illustrato che nullptr può essere assegnato a un puntatore nativo quando si utilizza /clr.
// mcpp_nullptr_6.cpp
// compile with: /clr
int main() {
int * i = 0;
int * j = nullptr;
}
Requisiti
Opzione del compilatore: (Non obbligatorio, supportate da tutte le opzioni di generazione del codice, inclusi /ZW e /clr)