Condividi tramite

nullptr (C++/CLI e C++/CX)

  • Articolo

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:

  • sizeof

  • typeid

  • throw nullptr (sebbene sia possibile usare throw (Object^)nullptr;)

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)

Vedi anche

Estensioni componenti per .NET e UWP
nullptr