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

  • Článek

Klíčové nullptr slovo představuje hodnotu ukazatele null. Hodnotu ukazatele null použijte k označení, že úchyt objektu, vnitřní ukazatel nebo nativní typ ukazatele neodkazuje na objekt.

Používá se nullptr se spravovaným nebo nativním kódem. Kompilátor generuje odpovídající, ale jiné pokyny pro spravované a nativní hodnoty ukazatele null. Informace o použití standardní verze jazyka C++ ISO tohoto klíčového slova naleznete v tématu nullptr.

Klíčové slovo __nullptr je klíčové slovo specifické pro Microsoft, které má stejný význam jako nullptr, ale vztahuje se pouze na nativní kód. Pokud použijete nullptr nativní kód C/C++ a pak zkompilujete s možností kompilátoru /clr , kompilátor nemůže určit, zda nullptr označuje nativní nebo spravovanou hodnotu ukazatele null. Chcete-li kompilátoru nullptr jasně určit, použijte k určení spravované hodnoty nebo __nullptr určit nativní hodnotu.

Klíčové nullptr slovo je ekvivalentem nothing v jazyce Visual Basic a null v jazyce C#.

Využití

Klíčové nullptr slovo lze použít kdekoli, kde lze použít popisovač, nativní ukazatel nebo argument funkce.

Klíčové nullptr slovo není typ a není podporováno pro použití s:

  • sizeof

  • typeid

  • throw nullptr (i když throw (Object^)nullptr; bude fungovat)

Klíčové nullptr slovo lze použít při inicializaci následujících typů ukazatelů:

  • Nativní ukazatel

  • popisovač prostředí Windows Runtime

  • Spravovaný popisovač

  • Spravovaný vnitřní ukazatel

Klíčové nullptr slovo lze použít k otestování, zda ukazatel nebo popisovač odkazu má hodnotu null před použití odkazu.

Volání funkcí mezi jazyky, které používají hodnoty nulového ukazatele pro kontrolu chyb, by měla být interpretována správně.

Popisovač nelze inicializovat na nulu; lze použít pouze nullptr . Přiřazení konstanty 0 k úchytu objektu vytvoří krabicové a přetypování Int32 na Object^.

Příklad: nullptr klíčové slovo

Následující příklad kódu ukazuje, že nullptr klíčové slovo lze použít všude, kde lze použít popisovač, nativní ukazatel nebo argument funkce. A příklad ukazuje, že nullptr klíčové slovo lze použít ke kontrole odkazu před jeho použití.

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

Příklad: Použití nullptr a nulová zaměnitelnost

Následující příklad kódu ukazuje, že nullptr a nula lze zaměnitelně u nativních ukazatelů.

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

Příklad: Interpretovat nullptr jako popisovač

Následující příklad kódu ukazuje, že nullptr je interpretován jako popisovač libovolného typu nebo nativní ukazatel na jakýkoli typ. V případě přetížení funkce s popisovači na různé typy se vygeneruje nejednoznačnost chyba. Musí nullptr být explicitně přetypován na typ.

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

Příklad: Přetypování nullptr

Následující příklad kódu ukazuje, že přetypování nullptr je povoleno a vrací ukazatel nebo popisovač na typ přetypování, který obsahuje nullptr hodnotu.

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

Příklad: Předání nullptr jako parametr funkce

Následující příklad kódu ukazuje, že nullptr lze použít jako parametr funkce.

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

int main() {
   f(nullptr);
}

test

Příklad: Výchozí inicializace

Následující příklad kódu ukazuje, že když obslužné rutiny jsou deklarovány a nejsou explicitně inicializovány, jsou výchozí inicializovány 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

Příklad: Přiřazení nullptr nativnímu ukazateli

Následující příklad kódu ukazuje, že nullptr lze přiřadit nativní ukazatel při kompilaci s /clr.

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

Požadavky

Možnost kompilátoru: (Nevyžaduje se, podporováno všemi možnostmi generování kódu, včetně /ZW a /clr)

Viz také

Přípony komponent pro .NET a UPW
nullptr