Übersicht über Deklaratoren

Deklaratoren sind die Komponenten einer Deklaration, die Namen von Objekten oder Funktionen angeben.Deklaratoren geben auch an, ob das benannte Objekt ein Objekt, ein Zeiger, ein Verweis oder ein Array ist.Während Deklaratoren nicht den Basistyp angeben, ändern Sie sie die Typinformationen im einfachen Typ, um abgeleitete Typen als Zeiger, Verweise und Arrays anzugeben.Angewendet auf die Funktionen, funktioniert der Deklarator mit dem Typspezifizierer, um den Rückgabetyp einer Funktion anzugeben, die vollständig von einem Objekt, Zeiger oder einen Verweis zu sein.(Die Angabe, in DeklarationenEigenschaften bereitstellen, wie Typ und Speicherklasse.Die Modifizierer in diesem Abschnitt und Microsoft-spezifische Modifiziererändern, Deklaratoren). Die folgende Abbildung zeigt eine vollständige Deklaration von MyFunctionan und ruft die Komponenten der Deklaration aus.

Modifizierern und Spezifizierer, Deklaratoren

Microsoft-spezifisch

Die meisten Microsoft erweiterte Schlüsselwörter können als Modifizierer verwendet werden, um abgeleitete Typen zu bilden. Deklaratoren Spezifizierer oder sie sind nicht.(Siehe Microsoft-spezifische Modifizierer).

Microsoft ENDES bestimmten

Deklaratoren werden in der Syntax für Deklarationen für eine optionale Liste mit Spezifizierern.Diese Bezeichner werden in Deklarationen.Beschreibung Eine Deklaration kann mehr als einen Deklarator enthalten, aber jeder Deklarator deklariert nur einen Namen.

Die folgende Beispiel veranschaulicht die Deklaration und Deklaratoren Bezeichner kombiniert werden, um eine vollständige Deklaration bilden:

const char *pch, ch;

In der vorherigen Deklaration bilden die Schlüsselwörter const und char die Liste der Spezifizierern.Zwei Deklaratoren werden aufgeführt: *pch und ch.Eine Deklaration, die mehrere Entitäten deklariert, besteht aus einem Typspezifizierer, der aus einer durch Trennzeichen getrennten Liste von Deklaratoren und endet mit einem Semikolon.

Deklaratoren für einfache Objekte

Der Deklarator eines einfachen Objekts, z. B. int oder ein Double-Wert ist einfach. B. den Namen, mit optionalen Klammern.

int i; // declarator is i

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

Deklaratoren für Zeiger, Verweise und Arrays

Die Zeiger Operatoren, die vor dem Namen eingefügt werden, bewirken das Objekt, Zeiger oder einen Verweis zu sein.Der Operator deklariert *-den Namen als Zeiger. Der &-Operator deklariert sie als Verweis.

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

const oder volatile wird, geben Sie den Zeiger diese speziellen Eigenschaften.Die Verwendung dieser Spezifizierern in einen Deklarator (im Gegensatz zur im Typspezifizierer) ändert die Eigenschaften des Zeigers, nicht auf das Objekt zeigt:

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

Weitere Informationen const und flüchtigen Zeigergefunden wird.

Ein Zeiger auf einen Member einer Klasse oder Struktur wird mit dem entsprechenden geschachtelten Name Parameterbezeichner deklariert:

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

Die Klammern, die einen optionalen konstanten Ausdruck nach dem Namen einschließen, wird das Objekt, ein Array zu sein.Aufeinander folgende Klammern deklarieren zusätzliche Dimensionen für das Array.

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

Deklaratoren für Funktionen

Die Klammern, die die Argumentliste enthalten, werden nach dem Namen verwendet, um eine Funktion zu deklarieren.Im Folgenden int des Rückgabetyps einer Funktion deklariert und drei Argumente Typs int.

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

Weitere Informationen über Argumentlisten finden Sie unter Funktionsdeklarationen.

Zeiger auf Funktionen und Verweise deklariert werden, indem Sie den Mauszeiger auf den Funktionsnamen Operator oder vorangestellt wird, wie unten dargestellt.Die Klammern sind optional, normalerweise erforderlich, einen Zeiger auf eine Funktion mit einer Funktion zu unterscheiden, die einen Zeiger zurückgibt:

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

Zeiger auf den Memberfunktionen sind über geschachtelte Name Parameterbezeichner definiert:

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

Siehe auch Zeiger auf Member.

Funktionen und Objekte in derselben Deklaration

Funktionen und Objekte werden in der gleichen Deklaration wie folgt deklariert werden:

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

Die Syntax ist unter bestimmten Umständen kann irreführend.Die folgende Deklaration

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

int wie die Deklaration eines Zeigers und der Funktion entsprechen möglicherweise int*zurückgibt, ist jedoch nicht.Das liegt daran, dass * ist Bestandteil des Deklarators für i, nicht Teil des Deklarators für f.

Deklaratoren Vereinfachung der Syntax mit typedef

Eine bessere Methode besteht darin, jedoch typedef oder eine Kombination von Klammern und typedef-Schlüsselwort zu verwenden.Verwenden Sie ein Array von Zeigern auf Funktionen zu deklarieren:

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

Die entsprechende Deklaration kann ohne die typedef Deklaration geschrieben werden, aber es ist ebenso schwierig, dass das Potenzial für Fehler alle Vorteile überschreitet:

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

Weitere Informationen finden Sie unter typedef Typedef-Spezifizierer.

Zeiger, verweist, Arrays eines einzelnen Basistyps können in einer einzigen Deklaration kombiniert werden (durch Trennzeichen getrennt) z.

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

Komplexere Syntax Deklaratoren

• Zeiger, Verweis Array und Funktionen deklaratoren werden kombiniert werden, um diese Objekte wie Arrays Zeiger auf Funktionen, Zeiger auf die Arrays anzugeben usw.

• Die folgende Syntax beschreibt Grammatik rekursive Zeiger deklaratoren vollständig.

• declarator wird als ein aus:

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

5. pointer-operator declarator 
6. ( declarator )

• OPERATOR ist ein Zeiger und aus:

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

Da ein Deklarator möglicherweise Deklaratoren enthält, ist es möglich, die komplexere abgeleiteten Typen wie Arrays, Funktionen zu erstellenden Arrays Funktionszeiger zurück, indem die oben genannten Regeln verwendet wird.Um die einzelnen Schritte der Erstellung zu erstellen, beginnen Sie mit dem Bezeichner, der den Basisdatentyp darstellt, und aktivieren Sie die Syntax die Regel oben mit dem vorherigen Ausdruck als declaratoran.Die Reihenfolge, in der Sie die Syntaxregeln verwenden, sollte die Umkehrung der Methode sein, die den Ausdruck auf Englisch angegeben wird.Wenn Sie den Zeiger OPERATOR-Syntax die Regel auf ein Array- oder Funktionsausdruck anwenden, verwenden Sie Klammern, wenn Sie einen Zeiger auf das Array oder Funktion, z. B. in der letzten Zeile in der Tabelle weiter unten.

Im folgenden Beispiel wird die Konstruktion „des Zeigers auf das Array von Zeigern auf 10 int“ an.

i

*i

(*i)[10]

*((*i)[10])

Wenn mehrere Bezugs- Array-, Zeiger- oder Funktion, modifizierer verwendet werden, werden möglicherweise Deklaratoren recht schwierig.Das Thema Komplexere interpretieren Deklaratoren wird beschrieben, wie komplexere Deklaratoren Attributsyntax liest.Das Thema ist in C und C++ verwendet werden, obwohl in C++ eine beliebige Stelle * verwendet wird, um einen Zeiger anzugeben, wie ein gekennzeichneter Name::MyClass* kann verwendet werden, um einen Zeiger auf einen Member einer Klasse angeben.

Siehe auch

Referenz

Deklaratoren