Tipos de ponteiro (Guia de Programação em C#)Pointer types (C# Programming Guide)

Em um contexto inseguro, um tipo pode ser de ponteiro, valor ou referência.In an unsafe context, a type may be a pointer type, a value type, or a reference type. Uma declaração de tipo de ponteiro usa uma das seguintes formas:A pointer type declaration takes one of the following forms:

type* identifier;
void* identifier; //allowed but not recommended

O tipo especificado antes do * em um tipo de ponteiro é chamado de tipo referent.The type specified before the * in a pointer type is called the referent type. Somente um tipo não gerenciado pode ser um tipo referent.Only an unmanaged type can be a referent type.

Os tipos de ponteiro não são herdados de objeto e não há nenhuma conversão entre tipos de ponteiro e object.Pointer types do not inherit from object and no conversions exist between pointer types and object. Além disso, as conversões boxing e unboxing não oferecem suporte a ponteiros.Also, boxing and unboxing do not support pointers. No entanto, você pode converter entre diferentes tipos de ponteiro e tipos de ponteiro e tipos integrais.However, you can convert between different pointer types and between pointer types and integral types.

Quando você designa vários ponteiros na mesma declaração, o asterisco (*) é escrito junto apenas com o tipo subjacente; ele não é usado como um prefixo para cada nome de ponteiro.When you declare multiple pointers in the same declaration, the asterisk (*) is written together with the underlying type only; it is not used as a prefix to each pointer name. Por exemplo:For example:

int* p1, p2, p3;   // Ok
int *p1, *p2, *p3;   // Invalid in C#

Um ponteiro não pode apontar para uma referência ou um struct que contenha referências, pois uma referência de objeto pode ser coletada como lixo mesmo se um ponteiro estiver apontando para ela.A pointer cannot point to a reference or to a struct that contains references, because an object reference can be garbage collected even if a pointer is pointing to it. O coletor de lixo não acompanha se um objeto está sendo apontado por qualquer tipo de ponteiro.The garbage collector does not keep track of whether an object is being pointed to by any pointer types.

O valor da variável de ponteiro do tipo myType* é o endereço de uma variável do tipo myType.The value of the pointer variable of type myType* is the address of a variable of type myType. Estes são exemplos de declarações de tipos de ponteiro:The following are examples of pointer type declarations:

ExemploExample DescriçãoDescription
int* p p é um ponteiro para um inteiro.p is a pointer to an integer.
int** p p é um ponteiro para um ponteiro para um inteiro.p is a pointer to a pointer to an integer.
int*[] p p é uma matriz unidimensional de ponteiros para inteiros.p is a single-dimensional array of pointers to integers.
char* p p é um ponteiro para um caractere.p is a pointer to a char.
void* p p é um ponteiro para um tipo desconhecido.p is a pointer to an unknown type.

O operador de indireção de ponteiro * pode ser usado para acessar o conteúdo no local apontado pela variável de ponteiro.The pointer indirection operator * can be used to access the contents at the location pointed to by the pointer variable. Por exemplo, considere a seguinte declaração:For example, consider the following declaration:

int* myVariable;

A expressão *myVariable denota a variável int encontrada no endereço contido em myVariable.The expression *myVariable denotes the int variable found at the address contained in myVariable.

Há vários exemplos de ponteiros nos tópicos Instrução fixed e Conversões de ponteiro.There are several examples of pointers in the topics fixed Statement and Pointer Conversions. O exemplo a seguir usa a palavra-chave unsafe e a instrução fixed e mostra como incrementar um ponteiro interior.The following example uses the unsafe keyword and the fixed statement, and shows how to increment an interior pointer. Você pode colar esse código na função principal de um aplicativo de console para executá-lo.You can paste this code into the Main function of a console application to run it. Estes exemplos precisam ser compilados com o conjunto de opções do compilador -unsafe.These examples must be compiled with the -unsafe compiler option set.

// Normal pointer to an object.
int[] a = new int[5] { 10, 20, 30, 40, 50 };
// Must be in unsafe code to use interior pointers.
unsafe
{
    // Must pin object on heap so that it doesn't move while using interior pointers.
    fixed (int* p = &a[0])
    {
        // p is pinned as well as object, so create another pointer to show incrementing it.
        int* p2 = p;
        Console.WriteLine(*p2);
        // Incrementing p2 bumps the pointer by four bytes due to its type ...
        p2 += 1;
        Console.WriteLine(*p2);
        p2 += 1;
        Console.WriteLine(*p2);
        Console.WriteLine("--------");
        Console.WriteLine(*p);
        // Dereferencing p and incrementing changes the value of a[0] ...
        *p += 1;
        Console.WriteLine(*p);
        *p += 1;
        Console.WriteLine(*p);
    }
}

Console.WriteLine("--------");
Console.WriteLine(a[0]);

/*
Output:
10
20
30
--------
10
11
12
--------
12
*/

Você não pode aplicar o operador de indireção para um ponteiro do tipo void*.You cannot apply the indirection operator to a pointer of type void*. No entanto, você pode usar uma conversão para converter um ponteiro nulo em qualquer outro tipo de ponteiro e vice-versa.However, you can use a cast to convert a void pointer to any other pointer type, and vice versa.

Um ponteiro pode ser null.A pointer can be null. Aplicar o operador de indireção a um ponteiro nulo causa um comportamento definido por implementação.Applying the indirection operator to a null pointer causes an implementation-defined behavior.

Passar ponteiros entre métodos pode causar um comportamento indefinido.Passing pointers between methods can cause undefined behavior. Considere usar um método que retorne um ponteiro para uma variável local por meio de um parâmetro in, out ou ref, ou como o resultado da função.Consider a method that returns a pointer to a local variable through an in, out, or ref parameter or as the function result. Se o ponteiro foi definido em um bloco fixo, a variável à qual ele aponta não pode mais ser corrigida.If the pointer was set in a fixed block, the variable to which it points may no longer be fixed.

A tabela a seguir lista os operadores e as instruções que podem operar em ponteiros em um contexto inseguro:The following table lists the operators and statements that can operate on pointers in an unsafe context:

Operador/InstruçãoOperator/Statement UsoUse
* Executa indireção de ponteiro.Performs pointer indirection.
-> Acessa um membro de um struct através de um ponteiro.Accesses a member of a struct through a pointer.
[] Indexa um ponteiro.Indexes a pointer.
& Obtém o endereço de uma variável.Obtains the address of a variable.
++ e --++ and -- Incrementa e decrementa ponteiros.Increments and decrements pointers.
+ e -+ and - Executa aritmética de ponteiros.Performs pointer arithmetic.
==, !=, <, >, <= e >===, !=, <, >, <=, and >= Compara ponteiros.Compares pointers.
stackalloc Aloca memória na pilha.Allocates memory on the stack.
fixedprivacidadefixed statement Corrige temporariamente uma variável para que seu endereço possa ser encontrado.Temporarily fixes a variable so that its address may be found.

Para obter mais informações sobre operadores relacionados a ponteiro, veja Operadores relacionados a ponteiro.For more information about pointer related operators, see Pointer related operators.

especificação da linguagem C#C# language specification

Para saber mais, confira a seção Tipos de ponteiro na Especificação da linguagem C#.For more information, see the Pointer types section of the C# language specification.

Veja tambémSee also