Declarações de ponteiro

Uma declaração de ponteiro nomeia uma variável de ponteiro e especifica o tipo de objeto para o qual a variável aponta. Uma variável declarada como um ponteiro contém um endereço de memória.

Sintaxe

declarator:
 pointer_opt direct-declarator

direct-declarator:
 identifier
 ( declarator )
 direct-declarator [ constant-expression_opt ]
 direct-declarator ( parameter-type-list )
 direct-declarator ( identifier-list_opt )

pointer:
 * type-qualifier-list_opt
 * type-qualifier-list_opt pointer

type-qualifier-list:
 type-qualifier
 type-qualifier-list type-qualifier

O type-specifier informa o tipo de objeto, que pode ser qualquer tipo básico, de estrutura ou união. As variáveis de ponteiro também podem apontar para funções, matrizes e outros ponteiros. (Para obter informações sobre como declarar e interpretar tipos de ponteiro mais complexos, consulte Interpretar declaradores mais complexos.)

Ao fazer o type-specifier void, é possível atrasar a especificação do tipo ao qual o ponteiro se refere. Esse item é chamado de "ponteiro para void" e escrito como void *. Uma variável declarada como um ponteiro para void pode ser usada para apontar para um objeto de qualquer tipo. No entanto, para realizar a maioria das operações no ponteiro ou no objeto para o qual ele aponta, o tipo para o qual ele aponta deve ser explicitamente especificado para cada operação. (Variáveis dos tipos char * e void * são compatíveis com a atribuição sem uma conversão de tipo). Essa conversão pode ser realizada com uma conversão de tipo. Para obter mais informações, confira Conversões de tipo.

O type-qualifier pode ser const ou volatile, ou ambos. Essas palavras-chave especificam, respectivamente, que o ponteiro não pode ser modificado pelo próprio programa (const) ou que o ponteiro pode ser modificado legitimamente por algum processo além do controle do programa (volatile). Para obter mais informações sobre const e volatile, consulte Qualificadores do tipo.

O declarator atribui um nome à variável e pode incluir um modificador de tipo. Por exemplo, se o declarator representa uma matriz, o tipo do ponteiro é modificado para ser um ponteiro para uma matriz.

Você pode declarar um ponteiro para uma estrutura, união ou tipo de enumeração antes de definir a estrutura, a união ou o tipo de enumeração. Você declara o ponteiro usando a estrutura ou a marca de união, como é mostrado nos exemplos. Essas declarações são permitidas porque o compilador não precisa saber o tamanho da estrutura ou da união para alocar espaço à variável de ponteiro.

Exemplos

Os exemplos a seguir ilustram as declarações de ponteiro.

char *message; /* Declares a pointer variable named message */

O ponteiro message aponta para uma variável com tipo char.

int *pointers[10];  /* Declares an array of pointers */

A matriz pointers tem 10 elementos; cada elemento é um ponteiro para uma variável com tipo int.

int (*pointer)[10]; /* Declares a pointer to an array of 10 elements */

A variável pointer aponta para uma matriz com 10 elementos. Cada elemento desta matriz tem o tipo int.

int const *x;      /* Declares a pointer variable, x,
                      to a constant value */

O ponteiro x pode ser modificado a fim de apontar a um valor int diferente, mas o valor para o qual ele aponta não pode ser modificado.

const int some_object = 5 ;
int other_object = 37;
int *const y = &fixed_object;
int volatile *const z = &some_object;
int *const volatile w = &some_object;

A variável y dessas declarações é declarada como um ponteiro constante para um valor int. O valor para o qual ele aponta pode ser modificado, mas o ponteiro em si deve sempre apontar para o mesmo local: o endereço de fixed_object. Da mesma forma, z é um ponteiro constante, mas também é declarado para apontar a um int cujo valor não pode ser modificado pelo programa. O especificador volatile indica que, embora o valor do const int apontado por z não possa ser modificado pelo programa, ele pode ser modificado legitimamente por um processo executado simultaneamente com o programa. A declaração de w especifica que o programa não pode alterar o valor apontado e que o programa não pode modificar o ponteiro.

struct list *next, *previous; /* Uses the tag for list */

Este exemplo declara duas variáveis de ponteiro (next e previous) que apontam para o tipo de estrutura list. Essa declaração pode aparecer antes da definição do tipo de estrutura list (consulte o próximo exemplo), desde que a definição de tipo list tenha a mesma visibilidade que a declaração.

struct list
{
    char *token;
    int count;
    struct list *next;
} line;

A variável line tem o tipo de estrutura chamado list. O tipo da estrutura list tem três membros: o primeiro membro é um ponteiro para um valor char, o segundo é um valor int e o terceiro é um ponteiro para uma outra estrutura list.

struct id
{
    unsigned int id_no;
    struct name *pname;
} record;

A variável record tem o tipo de estrutura id. pname é declarado como um ponteiro para outro tipo de estrutura chamado name. Essa declaração pode aparecer antes que o tipo name seja definido.

Confira também

Declaradores e declarações de variável