Declarações de ponteiro

Uma declaração de ponteiro nomeia uma variável de ponteiro e especifica o tipo do 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 _{opte por}direct-declarator

direct-declarator:
 identifier
  ( declarator )
  direct-declarator [ constant-expression _{optar por}]
  direct-declarator ( parameter-type-list )
  direct-declarator ( identifier-list _{optar por})

pointer:
  * type-qualifier-list _{optar por}
  * type-qualifier-list _{optar por}pointer

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

O type-specifier fornece o tipo do objeto, que pode ser qualquer tipo básico, 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 Interpretando declaradores mais complexos.)

Ao fazer o type-specifiervoid, você pode atrasar a especificação do tipo ao qual o ponteiro se refere. Esse item é referido como um "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 executar 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. (As variáveis de tipo char * e tipo void * são compatíveis com a atribuição sem uma conversão de tipo.) Essa conversão pode ser realizada com um tipo de molde. Para obter mais informações, consulte Type-Cast conversões.

O type-qualifier pode ser um 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 legitimamente modificado por algum processo fora do controle do programa (volatile). Para obter mais informações sobre const e volatile, consulte Qualificadores de tipo.

O declarator nomeia a variável e pode incluir um modificador de tipo. Por exemplo, se 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, união ou tipo de enumeração. Você declara o ponteiro usando a marca de estrutura ou união, conforme mostrado nos exemplos. Tais declarações são permitidas porque o compilador não precisa saber o tamanho da estrutura ou união para alocar espaço para a variável de ponteiro.

Exemplos

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

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

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

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

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

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

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

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

O ponteiro x pode ser modificado para apontar para um valor diferente int , 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 nessas declarações é declarada como um ponteiro constante para um int valor. O valor para o qual ele aponta pode ser modificado, mas o próprio ponteiro 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 para um int cujo valor não pode ser modificado pelo programa. O volatile especificador indica que, embora o const int valor do apontado por z não possa ser modificado pelo programa, ele poderia legitimamente ser modificado por um processo executado simultaneamente com o programa. A declaração de especifica que o programa não pode alterar o valor apontado w 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 listde estrutura . Esta declaração pode aparecer antes da definição do tipo de estrutura (ver o exemplo seguinte), desde que a list definição de list tipo 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 list tipo de estrutura tem três membros: o primeiro membro é um ponteiro para um char valor, o segundo é um int valor e o terceiro é um ponteiro para outra list estrutura.

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

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

Ver também

Declaradores e declarações variáveis