Visão geral de declaradores

Declaradores são os componentes de uma declaração que especificam os nomes de objetos ou funções.Declaradores também especificam se o objeto nomeado é um objeto, ponteiro, referência ou uma matriz.Enquanto declaradores não especificar o tipo base, eles modificar o tipo de informação para especificar os tipos derivados como ponteiros, referências e matrizes do tipo básico.O Declarador aplicado às funções, funciona com o especificador de tipo totalmente especificar o tipo de retorno de uma função para ser um objeto, um ponteiro ou uma referência.(Especificadores, discutidos no declarações, transmitir propriedades como o tipo e o armazenamento de classe.Modificadores, discutidos nesta seção e, em Modificadores específicas da Microsoft, modificar o declaradores.) A figura a seguir mostra uma declaração completa do MyFunctione chama os componentes da declaração.

Especificadores, modificadores e declaradores

Específicos do Microsoft

A maioria dos Microsoft estendidas de palavras-chave podem ser usadas como modificadores de formulário derivado tipos; eles não são especificadores ou declaradores.(Consulte modificadores específicas da Microsoft.)

Específicos do Microsoft final

Declaradores aparecem na sintaxe de declaração após uma lista opcional de especificadores.Esses especificadores são discutidas em declarações. Uma declaração pode conter mais de um Declarador, mas cada Declarador declara apenas um nome.

A declaração de exemplo a seguir mostra como os especificadores e declaradores são combinados para formar uma declaração completa:

const char *pch, ch;

Na declaração precedente, as palavras-chave const e char compõem a lista de especificadores.Dois declaradores estão listados: *pch e ch.Uma declaração que declara a várias entidades consiste em um especificador de tipo, seguido por uma lista separada por vírgulas de declaradores, foi encerrado com um ponto e vírgula.

Declaradores para objetos simples

O Declarador de um objeto simples, como um int ou double é simplesmente o nome, com parênteses opcionais.

int i; // declarator is i

int (i); // declarator is (i)

Declaradores de ponteiros, referências e matrizes

Operadores de ponteiro inseridos na frente do nome de fazer com que o objeto seja um ponteiro ou uma referência.O * operador declara o nome como um ponteiro; o & operador declara como uma referência.

int *i; // declarator is *i
int &i; // declarator is &i
int **i; // declarator is **i;

Acrescentando const ou volatile o ponteiro de dar a essas propriedades especiais.O uso desses especificadores em um Declarador (em vez no especificador de tipo) modifica as propriedades do ponteiro, e não o objeto apontado:

char *const cpc; // const pointer to char 
const char *pcc; // pointer to const char 
const char *const cpcc; // const pointer to const char

Mais informações podem ser encontradas em ponteiros const e volátil.

Um ponteiro para um membro de uma classe ou struct é declarado com o especificador de nome aninhadas apropriado:

int X::* pIntMember; 
int ::X::* pIntMember; // the initial :: specifies X is in global scope
char Outer::Inner::* pIntMember; // pointer to char in a nested class

Colchetes que envolve uma expressão constante opcional após o nome com que o objeto seja uma matriz.Colchetes sucessivas declarar outras dimensões à matriz.

int i[5]; // array with five elements of type int numbered from 0 to 4
int i[]; // array of unknown size
char *s[4]; // array of pointers to char
int i[2][2]; // two dimensional array

Declaradores para funções

Parênteses que contém a lista de argumentos são usados após o nome para declarar uma função.A seguir declara uma função do tipo de retorno int e três argumentos do tipo int.

int f(int a, int b, int c);

Para obter informações sobre listas de argumentos, consulte Declarações de função.

Ponteiros e referências às funções são declaradas, antecedendo o ponteiro ou o operador de referência ao nome da função, como mostrado abaixo.Entre parênteses, normalmente é opcionais, são necessárias para distinguir um ponteiro para uma função de uma função que retorna um ponteiro:

int (*pf)(int); // pointer to function returning int
int *f(int i); // function returning pointer to int
int (&pf)(int); // reference to function 

Ponteiros para funções de membro são diferenciados por especificadores de nome aninhados:

int (X::* pmf)(); // pointer to member function of X returning int
int* (X::* pmf)(); // pointer to member function returning pointer to int

Consulte também ponteiros para os membros.

Funções e objetos na mesma declaração

Funções e objetos podem ser declarados na mesma declaração da seguinte maneira:

int i, *j, f(int k);  // int, pointer to int, function returning int

A sintaxe pode ser enganosa em algumas circunstâncias.A declaração a seguir

int* i, f(int k);  // pointer to int, function returning int (not int*)

pode parecer com a declaração de um int ponteiro e uma função de retorno de int*, mas não é.Isso ocorre porque o * faz parte o Declarador de i, não faz parte do Declarador de f.

Simplificando a sintaxe declarativa com typedef

Uma técnica melhor, no entanto, é usar um typedef ou uma combinação de parênteses e o typedef palavra-chave.Considere a possibilidade de declarar uma matriz de ponteiros para funções:

//  Function returning type int that takes one 
//   argument of type char *.
typedef int (*PIFN)( char * );
//  Declare an array of 7 pointers to functions 
//   returning int and taking one argument of type 
//   char *.
PIFN pifnDispatchArray[7];

A declaração equivalente pode ser escrita sem a typedef declaração, mas é tão complicado que o potencial de erro excede nenhum benefício:

int ( *pifnDispatchArray[7] )( char * );

Para obter mais informações sobre typedef, consulte typedef especificador.

Ponteiros, referências, matrizes de um único tipo de base podem ser combinados em uma única declaração (separada por vírgulas) como

int i, *i, &i, i[5];

Sintaxe de mais complexa Declarador

• Ponteiro, referência, array e declaradores de função podem ser combinados para especificar esses objetos como matrizes de ponteiros para funções, ponteiros para conjuntos, etc.

• A seguinte gramática recursiva descreve a sintaxe declarativa de ponteiro totalmente.

• A declarator é definido como um destes:

1. identifier 
2. qualified-name 
3. declarator ( argument-list ) [cv-qualfiers] [exception-spec]
4. declarator [ [ constant-expression ] ] 

5. pointer-operator declarator 
6. ( declarator )

• e operador de ponteiro é uma das:

* [cv-qualifiers]
& [cv-qualifiers]
:: nested-name-specifier * [cv-qualfiers]

Como um Declarador pode conter declaradores, é possível construir os tipos derivados mais complexos, como matrizes de ponteiros, funções retornam matrizes de ponteiros de função, utilizando as regras acima.Para formar cada etapa de construção, comece com o identificador que representa os dados básicos, digite e aplicam a regra de sintaxe acima com a expressão anterior, como o declarator.A ordem em que você aplicar as regras de sintaxe deve ser o inverso da maneira como a expressão é declarada em inglês.Se aplicando a operador de ponteiro regra de sintaxe para uma expressão de função ou de matriz, use parênteses se desejar que um ponteiro para a matriz ou uma função, como na última linha na tabela abaixo.

O exemplo a seguir mostra a construção de "ponteiro para matriz de 10 ponteiros para int".

Expressão verbal	Declarador	Regra de sintaxe aplicada
	i	1
indicador de	*i	5
matriz de 10	(*i)[10]	4
ponteiro para	*((*i)[10])	6 e, em seguida, 5

Quando vários ponteiro, referência, matriz ou funcionar modificadores são usadas, declaradores podem se tornar bastante complicados.O tópico Interpretando mais complexos declaradores descreve como ler a sintaxe de mais complexa Declarador.O tópico é aplicável a c e C++, embora no C++, em qualquer lugar do * é usado para indicar um ponteiro, um nome qualificado como, por exemplo, MyClass:: * pode ser usado para especificar um ponteiro para um membro de uma classe.

Consulte também

Referência

Declaradores