nullptr (C++/CLI a C++/CX)
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:
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)