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

Das nullptr Schlüsselwort stellt einen Nullzeigerwert dar. Verwenden Sie einen NULL-Zeigerwert, um anzugeben, dass ein Zeiger des Typs „Objekthandle“, „Innerer Zeiger“ oder „Nativer Zeiger“ nicht auf ein Objekt zeigt.

Wird entweder mit verwaltetem oder systemeigenem Code verwendet nullptr . Der Compiler gibt geeignete, aber unterschiedliche Anweisungen für verwaltete und native NULL-Zeigerwerte aus. Informationen zur Verwendung der C++-Version nach ISO-Standard dieses Schlüsselworts finden Sie unter nullptr.

Das schlüsselwort __nullptr ist ein microsoftspezifisches Schlüsselwort, das die gleiche Bedeutung hat wie nullptr, gilt aber nur für systemeigenen Code. Wenn Sie mit systemeigenem C/C++-Code arbeiten nullptr und dann mit der Compileroption "/clr " kompilieren, kann der Compiler nicht ermitteln, ob nullptr ein systemeigener oder verwalteter Nullzeigerwert angegeben ist. Um den Compiler klar zu machen, verwenden Sie nullptr zum Angeben eines verwalteten Werts oder __nullptr zum Angeben eines nativen Werts.

Das nullptr Schlüsselwort entspricht Nothing in Visual Basic und NULL in C#.

Verbrauch

Das nullptr Schlüsselwort kann an einer beliebigen Stelle verwendet werden, an der ein Handle, ein systemeigener Zeiger oder ein Funktionsargument verwendet werden kann.

Das nullptr Schlüsselwort ist kein Typ und wird für die Verwendung mit:

• sizeof

• typeid

• throw nullptr (obwohl throw (Object^)nullptr; funktioniert)

Das nullptr Schlüsselwort kann in der Initialisierung der folgenden Zeigertypen verwendet werden:

• Nativer Zeiger

• Windows-Runtime-Handle

• Verwaltetes Handle

• Verwalteter innerer Zeiger

Das nullptr Schlüsselwort kann verwendet werden, um zu testen, ob ein Zeiger oder Handleverweis null ist, bevor der Verweis verwendet wird.

Funktionsaufrufe zwischen Sprachen, die NULL-Zeigerwerte für die Fehlerüberprüfung verwenden, sollten richtig interpretiert werden.

Sie können kein Handle auf Null initialisieren. kann nur nullptr verwendet werden. Die Zuweisung der Konstante 0 zu einem Objekthandle hat ein geschachteltes Int32 und eine Umwandlung in Object^ zur Folge.

Beispiel: nullptr Schlüsselwort

Im folgenden Codebeispiel wird veranschaulicht, dass das nullptr Schlüsselwort überall verwendet werden kann, wo ein Handle, ein systemeigener Zeiger oder ein Funktionsargument verwendet werden kann. Das Beispiel zeigt, dass das nullptr Schlüsselwort verwendet werden kann, um einen Verweis zu überprüfen, bevor er verwendet wird.

// 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 ^)
}

Beispiel: Verwendung nullptr und Null austauschbar

Das folgende Codebeispiel zeigt, dass nullptr und Null austauschbar auf systemeigenen Zeigern verwendet werden kann.

// 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

Beispiel: Als Handle interpretieren nullptr

Das folgende Codebeispiel zeigt, dass nullptr als Handle für einen beliebigen Typ oder einen systemeigenen Zeiger auf einen beliebigen Typ interpretiert wird. Bei einer Funktionsüberladung mit Handles zu verschiedenen Typen wird ein Mehrdeutigkeitsfehler generiert. Dies nullptr müsste explizit in einen Typ gegossen werden.

// 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);
}

Beispiel: Cast nullptr

Das folgende Codebeispiel zeigt, dass Umwandlungen nullptr zulässig sind und einen Zeiger oder ein Handle an den Umwandlungstyp zurückgibt, der den nullptr Wert enthält.

// 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)
}

Beispiel: Übergeben nullptr als Funktionsparameter

Das folgende Codebeispiel zeigt, dass nullptr als Funktionsparameter verwendet werden kann.

// mcpp_nullptr_4.cpp
// compile with: /clr
using namespace System;
void f(Object ^ x) {
   Console::WriteLine("test");
}

int main() {
   f(nullptr);
}

test

Beispiel: Standardinitialisierung

Das folgende Codebeispiel zeigt, dass bei deklarierten und nicht explizit initialisierten Handles standardmäßig initialisiert nullptrwerden.

// 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

Beispiel: Zuweisen nullptr zu einem systemeigenen Zeiger

Das folgende Codebeispiel zeigt, dass nullptr einem systemeigenen Zeiger beim Kompilieren zugewiesen /clrwerden kann.

// mcpp_nullptr_6.cpp
// compile with: /clr
int main() {
   int * i = 0;
   int * j = nullptr;
}

Anforderungen

Compileroption: (Nicht erforderlich; wird von allen Codegenerierungsoptionen unterstützt, einschließlich /ZW und /clr)

Siehe auch

Komponentenerweiterungen für .NET und UWP
nullptr