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:
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ą /clr
polecenia .
// 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