nullptr (Extensões de Componentes C++)

Artigo
02/25/2013

A palavra-chave de nullptr representa um valor de ponteiro nulo.Use um valor nulo de ponteiro para indicar que um identificador de objeto, um ponteiro interior, ou nativo um tipo ponteiro não apontam para um objeto.

use nullptr com código gerenciado ou nativo.O compilador emite-se instruções apropriados mas diferentes para valores de ponteiro nulo nativos e gerenciados.Para obter informações sobre como usar a versão do padrão ISO C++ de esta palavra-chave, consulte nullptr.

A palavra-chave de __nullptr é um vstemplate palavra-chave específica que tem o mesmo significado que nullptr, mas só se aplica ao código nativo.Se você usar nullptr com código nativo C/C++ do e então cria com a opção de compilador /clr , o compilador não pode determinar se nullptr indica um nativo ou um valor nulo de ponteiro gerenciado.Para tornar seu espaço livre intenção do compilador, use nullptr para especificar um valor gerenciado ou __nullptr para especificar um valor para o código nativo.

A palavra-chave de nullptr é equivalente a Nothing no Visual Basic e o null C#.

Uso

A palavra-chave de nullptr pode ser usado em qualquer lugar um manipulador, ponteiro nativo, ou o argumento da função pode ser usado.

A palavra-chave de nullptr não é um tipo e não é suportado para uso com:

sizeof
typeid
throw nullptr (embora throw (Object^)nullptr; funcionará)

A palavra-chave de nullptr pode ser usado na inicialização dos seguintes tipos ponteiro:

ponteiro nativo
Tempo de execução manipulam do windows
Identificador gerenciado
Ponteiro gerenciado dentro

A palavra-chave de nullptr pode ser usado para testar se uma referência de ponteiro ou alça é nulo antes que a referência é usada.

As chamadas de função entre linguagens que usam valores de ponteiro zero para verificação de erros devem ser interpretado corretamente.

Você não pode inicializar um identificador para zero; somente nullptr pode ser usado.A atribuição de constante 0 para um identificador de objeto gera Int32 disponível comercialmente e uma conversão a Object^.

Exemplo

O exemplo de código que demonstra a palavra-chave de nullptr pode ser usado onde um manipulador, ponteiro nativo, ou argumento da função pode ser usada.E o exemplo demonstra que a palavra-chave de nullptr pode ser usado para verificar uma referência antes que tenha usado.

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

Exemplo

O exemplo de código a seguir mostra o nullptr zero e podem ser usados de forma intercambiável em ponteiros nativas.

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

Saída

Exemplo

O exemplo de código a seguir mostra nullptr que é interpretado como um identificador a qualquer tipo ou um ponteiro nativo a qualquer tipo.Em caso de sobrecarga de função com alças para diferentes tipos, um erro de ambigüidade será gerado.nullptr terá que ser convertido para um tipo explicitamente.

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

Exemplo

O exemplo de código a seguir mostra que converter nullptr é permitido e retorna um ponteiro ou um identificador para o tipo de conversão que contém o valor de nullptr .

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

Exemplo

O exemplo de código a seguir mostra nullptr que pode ser usado como um parâmetro de função.

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

int main() {
   f(nullptr);
}

Saída

Exemplo

O exemplo de código a seguir mostra que quando identificadores são declaradas e não inicializadas explicitamente, eles é inicializada a opção 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();
}

Saída

Exemplo

O exemplo de código a seguir mostra nullptr que pode ser atribuído a um ponteiro nativo quando você compila com /clr.

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

Requisitos

Opção de compilador: (Não seja necessário; suportados por todas as opções de geração de código, incluindo /ZW e /clr)

Compartilhar via

nullptr (Extensões de Componentes C++)

Uso

Exemplo

Requisitos

Consulte também

Referência

Conceitos

Recursos adicionais