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

Słowo nullptr kluczowe reprezentuje wartość wskaźnika null. Użyj wartości wskaźnika null, aby wskazać, że uchwyt obiektu, wskaźnik wewnętrzny lub natywny typ wskaźnika nie wskazuje obiektu.

Użyj z nullptr kodem zarządzanym lub natywnym. Kompilator emituje odpowiednie, ale różne instrukcje dotyczące zarządzanych i natywnych wartości wskaźnika null. Aby uzyskać informacje na temat używania standardowej wersji języka C++ iso tego słowa kluczowego, zobacz nullptr.

Słowo kluczowe __nullptr to słowo kluczowe specyficzne dla firmy Microsoft, które ma takie samo znaczenie jak nullptr, ale dotyczy tylko kodu natywnego. Jeśli używasz z nullptr natywnym kodem C/C++, a następnie kompilujesz z opcją kompilatora /clr , kompilator nie może określić, czy nullptr wskazuje natywną, czy zarządzaną wartość wskaźnika null. Aby wyjaśnić intencję kompilatora, użyj polecenia nullptr , aby określić wartość zarządzaną lub __nullptr , aby określić wartość natywną.

Słowo nullptr kluczowe jest równoważne niczym w Visual Basic i null w języku C#.

Użycie

Słowo nullptr kluczowe może być używane w dowolnym miejscu, gdzie można użyć uchwytu, wskaźnika natywnego lub argumentu funkcji.

Słowo nullptr kluczowe nie jest typem i nie jest obsługiwane do użycia z:

• sizeof

• typeid

• throw nullptr (chociaż throw (Object^)nullptr; będzie działać)

Słowo nullptr kluczowe może być używane w inicjowaniu następujących typów wskaźników:

• Wskaźnik natywny

• dojście środowisko wykonawcze systemu Windows

• Dojście zarządzane

• Wskaźnik wnętrza zarządzanego

Słowo nullptr kluczowe może służyć do testowania, czy wskaźnik lub odwołanie do obsługi ma wartość null przed użyciem odwołania.

Wywołania funkcji między językami, które używają wartości wskaźnika null do sprawdzania błędów, powinny być prawidłowo interpretowane.

Nie można zainicjować dojścia do zera; można używać tylko nullptr tych, których można użyć. Przypisanie stałej 0 do uchwytu obiektu powoduje utworzenie pola Int32 i rzutowania na Object^.

Przykład: nullptr słowo kluczowe

Poniższy przykład kodu pokazuje, że słowo kluczowe może być używane wszędzie tam, nullptr gdzie można użyć uchwytu, wskaźnika natywnego lub argumentu funkcji. W przykładzie pokazano, że nullptr słowo kluczowe może służyć do sprawdzania odwołania przed jego zastosowaniem.

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

Przykład: użycie nullptr i zero zamiennie

Poniższy przykład kodu pokazuje, że nullptr i zero mogą być używane zamiennie na natywnych wskaźników.

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

Przykład: Interpretowanie nullptr jako uchwytu

Poniższy przykład kodu pokazuje, że nullptr jest interpretowany jako uchwyt dla dowolnego typu lub natywnego wskaźnika do dowolnego typu. W przypadku przeciążenia funkcji z uchwytami do różnych typów zostanie wygenerowany błąd niejednoznaczności. Musiałby nullptr zostać jawnie oddany do typu.

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

Przykład: rzutowanie nullptr

Poniższy przykład kodu pokazuje, że rzutowanie nullptr jest dozwolone i zwraca wskaźnik lub uchwyt do typu rzutowania zawierającego nullptr wartość.

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

Przykład: Przekazywanie nullptr jako parametru funkcji

Poniższy przykład kodu pokazuje, że nullptr można go użyć jako parametru funkcji.

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

int main() {
   f(nullptr);
}

test

Przykład: Inicjowanie domyślne

Poniższy przykład kodu pokazuje, że gdy dojścia są zadeklarowane i nie są jawnie inicjowane, są one domyślnie inicjowane na 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

Przykład: Przypisywanie nullptr do natywnego wskaźnika

Poniższy przykład kodu pokazuje, że nullptr można przypisać do natywnego wskaźnika podczas kompilowania za pomocą /clrpolecenia .

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

Wymagania

Opcja kompilatora: (Nie jest to wymagane; obsługiwane przez wszystkie opcje generowania kodu, w tym /ZW i /clr)

Zobacz też

Rozszerzenia składników dla platformy .NET i platformy uniwersalnej systemu Windows
nullptr