Cenni preliminari sui dichiaratori

I dichiaratori sono componenti di una dichiarazione che specificano i nomi degli oggetti o funzioni.I dichiaratori specificano anche indipendentemente dal fatto che l'oggetto denominato è un oggetto, un puntatore, un riferimento o una matrice.Mentre i dichiaratori non specificano il tipo di base, ma solo le informazioni sul tipo nel tipo di base per specificare i tipi derivati come puntatori, i riferimenti e matrici.Applicato alle funzioni, al dichiaratore con l'identificatore del tipo completamente per specificare il tipo restituito della funzione per essere un oggetto, il puntatore, o al riferimento.(Identificatori, descritti in dichiarazioni, indicare le proprietà come tipo e la classe di archiviazione.Modificatori, descritti in questa sezione e in Modificatori specifici microsoft, modificare i dichiaratori). Nella figura seguente viene illustrata una dichiarazione completa di MyFunctione ai componenti di dichiarazione.

Identificatori, e modificatori dichiaratori

Specifici di Microsoft

La maggior parte delle parole chiave estese di Microsoft possono essere utilizzate come modificatori per formare i tipi derivati; non sono identificatori o dichiaratori.(Vedere Modificatori specifici microsoft).

Microsoft FINALE specifico

I dichiaratori vengono visualizzati nella sintassi di dichiarazione dopo un elenco facoltativo degli identificatori.Questi identificatori sono illustrati in dichiarazioni. Una dichiarazione può contenere più di un dichiaratore, ma ogni dichiarazione dichiara un solo nome.

Illustrato nella dichiarazione di esempio come identificatori e i dichiaratori combinati per formare una dichiarazione completa:

const char *pch, ch;

Nella dichiarazione precedente, le parole chiave const e char costituiscono l'elenco degli identificatori.Due dichiaratori vengono elencate: *pch e ch.Una dichiarazione che dichiara più entità è costituito da un identificatore del tipo e da un elenco delimitato da virgole di dichiaratori, terminato con un punto e virgola.

dichiaratori per gli oggetti semplici

Il dichiaratore di un oggetto semplice come int o un doppio è semplicemente il nome, con le parentesi facoltative.

int i; // declarator is i

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

dichiaratori per i puntatori, i riferimenti e le matrici

Gli operatori del puntatore di inserimento davanti al nome determinano l'oggetto a essere un puntatore o un riferimento.* l'operatore dichiara il nome di un puntatore, & l'operatore lo dichiara come riferimento.

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

Aggiungere const o volatile assegnare al puntatore queste proprietà speciali.L'utilizzo di questi identificatori in un dichiaratore anziché l'identificatore del tipo) modificare le proprietà del puntatore, non l'oggetto fa riferimento a:

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

Ulteriori informazioni sono disponibili in const e puntatori volatili.

Un puntatore A un membro di una classe o della struttura è dichiarato con l'identificatore annidato appropriato di nome:

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

Parentesi che racchiudono un'espressione costante facoltativa dopo che la causa di nome l'oggetto come una matrice.Le parentesi successivi vengono dichiarate le dimensioni della matrice.

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

dichiaratori per le funzioni

Le parentesi tonde che contengono l'elenco di argomenti vengono utilizzate dopo il nome per dichiarare una funzione.L'esempio seguente dichiara una funzione di tipo restituito int e tre argomenti di tipo int.

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

per informazioni sugli elenchi di argomenti, vedere Dichiarazioni di funzione.

I puntatori e i riferimenti alle funzioni vengono dichiarati al puntatore o l'operatore di riferimento al nome di funzione come illustrato di seguito.Le parentesi, in genere facoltative, sono necessarie distinguere un puntatore a una funzione di una funzione che restituisce un puntatore:

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

I puntatori a funzioni membro sono distinti dagli identificatori annidati di nome:

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

vedere inoltre puntatori ai membri.

Funzioni e oggetti nella stessa dichiarazione

Le funzioni e gli oggetti possono essere dichiarati nella stessa dichiarazione come segue:

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

La sintassi può essere fuorviante in alcune circostanze.la seguente dichiarazione

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

può essere simile alla dichiarazione di un oggetto int puntatore e la restituzione di funzione int*, ma non è.Questo perché * fa parte del dichiaratore per i, non parte dei dichiaratori per f.

Semplificare la sintassi del dichiaratore con il typedef

Una migliore tecnica, tuttavia, di utilizzare un oggetto typedef o una combinazione di parentesi e typedef parola chiave.Si consiglia di dichiarare una matrice di puntatori a funzioni:

//  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 dichiarazione equivalente può essere scritta senza typedef la dichiarazione, ma è così complessi che la possibilità di errori supera i vantaggi:

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

Per ulteriori informazioni sul typedef, vedere identificatore di typedef.

I puntatori, riferimenti, matrici di un solo tipo di base possono essere combinati in una singola dichiarazione (separata da virgole) come

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

Sintassi più complessa del dichiaratore

• Il puntatore, il riferimento, la matrice e i dichiaratori di funzione possono essere combinati per specificare tali oggetti quali matrici di puntatori a funzioni, i puntatori a matrici, e così via.

• La seguente sintassi ricorsiva viene descritta la sintassi di dichiarazione di puntatore comuni.

• In declarator viene definito come uno di:

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

5. pointer-operator declarator 
6. ( declarator )

• e puntatore-operatore è uno di:

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

Poiché un dichiaratore può contenere i dichiaratori, è possibile costruire i tipi derivati più complessi come matrici dei puntatori, funzioni restituire le matrici i puntatori a funzione, utilizzando le regole di precedenza.Per formare ogni passaggio della costruzione, che inizi con l'identificatore che rappresenta il tipo di dati di base e applicare la regola di sintassi precedente con l'espressione precedente come declarator.L'ordine di applicare le regole di sintassi deve essere l'opposto della modalità con cui l'espressione viene dichiarata in inglese.Se applicare puntatore-operatore regola di sintassi a un'espressione di funzione o di matrice, utilizzare le parentesi per ottenere un puntatore a matrice o alla funzione, come nell'ultima riga nella tabella riportata di seguito.

Nell'esempio seguente viene illustrata la costruzione di “puntatore a una matrice di 10 puntatori al tipo int„.

i

*i

(*i)[10]

*((*i)[10])

Quando più modificatori del puntatore, di riferimento, di una matrice o di funzione vengono utilizzati, i dichiaratori possono essere piuttosto complessi.l'argomento Interpretazione dei dichiaratori più complessi viene descritto come leggere la sintassi più complessa del dichiaratore.L'argomento è applicabile sia in C che in C++, sebbene in C++, ovunque * sia utilizzata per indicare un puntatore, un nome completo come MyClass:: * può essere utilizzato per specificare un puntatore A un membro di una classe.

Vedere anche

Riferimenti

Dichiaratori