Información general de Declarators

Los declarantes son componentes de una declaración que especifican los nombres de objetos o funciones.Los declarantes también especifican si el objeto con nombre es un objeto, puntero, una referencia o una matriz.Mientras que los declarantes no especifican el tipo base, modificar la información de tipos en el tipo básico para especificar tipos derivados como punteros, referencias, y matrices.Se aplica a las funciones, el declarador ejecuta el especificador de tipo para especificar el tipo de valor devuelto de una función para ser un objeto, puntero, o referencia.(Especificadores, descritos en declaraciones, transmiten propiedades como tipo y clase de almacenamiento.Los modificadores, descritos en esta sección y en Modificadores específicos, modificar declarantes.) La ilustración siguiente muestra la declaración completa de MyFunction, y llama a los componentes de la declaración.

especificadores, modificadores, y Declarators

Específicos de Microsoft

La mayoría de Microsoft extendidas las palabras clave se puede utilizar como modificadores para formar tipos derivados; no son especificadores o declarantes.(Vea Modificadores específicos.)

Específico de Microsoft de FINAL

Los declarantes aparecen en la sintaxis de declaración después de una lista opcional de especificadores.Describen a estos especificadores en declaraciones. Una declaración puede contener varios declarador, pero cada declarador declara sólo un nombre.

La declaración del ejemplo siguiente se muestra cómo se combinan los especificadores y los declarantes para formar una declaración completa:

const char *pch, ch;

En la declaración anterior, las palabras clave const y char constituyen la lista de especificadores.Se muestran dos declarantes: *pch y ch.Una declaración que declara varias entidades consta de un especificador de tipo seguido por una lista separada por comas de declarantes, finaliza con un punto y coma.

Declarantes para objetos de Simple

El declarador de un objeto simple como int o double es simplemente el nombre, con paréntesis opcionales.

int i; // declarator is i

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

Declarantes para punteros, las referencias y matrices

Los operadores de puntero insertados delante del nombre hacen que el objeto como puntero o referencia.El operador * declara el nombre como puntero; y operador se declara como referencia.

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

anexando const o volatile dé a puntero estas propiedades especiales.El uso de estos especificadores en un declarador (en comparación con el especificador de tipo) modifica las propiedades del puntero, no el objeto informa a:

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

Información adicional se puede encontrar en const y volatile punteros.

Un puntero a un miembro de una clase o struct se declara con el especificador anidados adecuado de nombre:

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

Los corchetes que agregan una expresión constante opcional después del nombre hacen que el objeto sea una matriz.Los corchetes sucesivos declaran dimensiones adicionales a la 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

Declarantes para funciones

Paréntesis que contienen la lista de argumentos se utilizan después del nombre para declarar una función.Lo siguiente declara una función del tipo de valor devuelto int y tres argumentos de intescrito.

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

Para obtener información sobre las listas de argumentos, vea declaraciones de función.

Los punteros y las referencias a las funciones se declaran anteponiendo el puntero u operador de referencia al nombre de función como se muestra a continuación.Paréntesis, normalmente opcionales, se requieren para distinguir un puntero a una función de una función que devuelve un puntero:

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

Los punteros a funciones miembro se distinguen por los especificadores anidado de nombre:

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

Vea también Punteros a miembros.

Funciones y objetos de la misma declaración

las funciones y los objetos se pueden declarar en la misma declaración como sigue:

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

La sintaxis puede ser engañosa en determinadas circunstancias.la siguiente declaración

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

puede parecer la declaración de un puntero de int y una función devolver int*, pero no es.Esto se debe a que * es parte de declaradores para i, no parte de declaradores para f.

Simplificar de sintaxis de declaradores con typedef

Una mejor técnica, sin embargo, es utilizar typedef o una combinación de paréntesis y la palabra clave de typedef .Plantéese declarar una matriz de punteros a funciones:

//  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];

La declaración equivalente se puede escribir sin la declaración de typedef , pero es más complicado que las posibilidades de error supera a cualquier marcado:

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

Para obtener más información sobre typedef, vea especificador typedef.

Los punteros, referencias, matrices de un solo tipo base se pueden combinar en una sola declaración (separados por comas) como

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

Una sintaxis más compleja de declaradores

• El puntero, la referencia, la matriz, y los declarantes de función se pueden combinar para especificar objetos como matrices de punteros a funciones, de punteros a matrices, de etc.

• La gramática recursiva siguiente describe la sintaxis de declarador de puntero totalmente.

• declarator se define como uno de:

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

5. pointer-operator declarator 
6. ( declarator )

• y el puntero- operador es uno de:

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

Dado que un declarador puede contener declarantes, es posible construir los tipos derivados más complejos como matrices de punteros, funciones y matrices de punteros a función, utilizando las reglas anteriores.Para formar cada paso de la construcción, comience con el identificador que representa el tipo de datos base y aplica la regla de sintaxis anterior con la expresión anterior como declarator.El orden que aplica las reglas de sintaxis debe ser el inverso de la manera que la expresión se indica en inglés.Si se aplica la regla de sintaxis de puntero-operador a una expresión de matriz o de función, utilice paréntesis si desea un puntero a la matriz o función, como en la última fila en la tabla siguiente.

El ejemplo siguiente se muestra la construcción de “un puntero a la matriz de 10 punteros a int”.

expresión verbal	Enumeration	La regla de sintaxis aplicado
	i	1
punteros a	*i	5
matriz de 10	(*i)[10]	4
puntero a	*((*i)[10])	6 y 5

Cuando se utilizan varios modificadores de puntero, de referencia, de matriz o de la función, los declarantes pueden volverse bastante complicados.El tema interpretación de declarantes más complejos describe cómo leer una sintaxis más compleja de declaradores.El tema es aplicable a C y C++, aunque en C++, dondequiera * se utiliza para indicar un puntero, un nombre calificado como MyClass:: * se puede utilizar para especificar un puntero a un miembro de una clase.

Vea también

Referencia

Declarantes