Deklarationen und Deklaratoren
Nach oben zu Deklarationssyntax - Index
Eine Deklaration ist eine Liste mit Namen. Diese Namen werden manchmal Deklaratoren oder Bezeichner genannt. Die Deklaration beginnt mit den optionalen Speicherklassen-Bezeichnern, den Typ-Bezeichnern und anderen Modifizierern. Die Bezeichner werden durch Kommata voneinander getrennt. Die Liste wird durch ein Semikolon abgeschlossen.
Einfache Deklarationen von Variablenbezeichnern haben folgendes Muster:
Datentyp var1 <=init1>, var2 <=init2>, ...;
wobei var1, var2,... eine beliebige Folge verschiedener Bezeichner darstellt, die zusätzlich Initialisierer enthalten kann. Alle Variablen sind vom Typ Datentyp. Beispielsweise erstellt
int x = 1, y = 2;
zwei Integer-Variablen x und y (und initialisiert sie mit den Werten 1 beziehungsweise 2).
Es handelt sich hierbei um definierende Deklarationen, das heißt, es erfolgt eine Speicherzuweisung und die optionalen Initialisierer werden angewendet.
Als Initialisierer für ein automatisches Objekt kann jeder zulässige Ausdruck verwendet werden, der zu einem zuweisungskompatiblen Wert für den Typ der betreffenden Variable ausgewertet werden kann. Die Initialisierer für statische Objekte müssen Konstanten oder Konstantenausdrücke sein.
In C++ kann jeder Ausdruck mit Konstanten und bereits deklarierten Variablen und Funktionen als Initialisierer für ein statisches Objekt verwendet werden.
Das Format des Deklarators zeigt an, wie der deklarierte Name in einem Ausdruck interpretiert werden soll. Wenn type ein beliebiger Typ, der Speicherklassen-Bezeichner ein beliebiger Speicherklassen-Bezeichner ist, und wenn D1 und D2 zwei Deklaratoren sind, dann gibt die Deklaration:
Speicherklassen-Bezeichner type D1, D2;
an, dass D1 und D2 jedes Mal als Objekte des Typs type behandelt werden sollen und die Speicherklasse Speicherklassen-Bezeichner ist, wenn sie in einem Ausdruck vorkommen. Der in den Deklarator eingebettete Typ des Namens ist ein Ausdruck, der type (wie "type", "Zeiger auf type", "Array von type", "Funktion liefert type" oder "Zeiger auf die Funktion, die type liefert" usw.) enthält.
Zum Beispiel kann jeder in den folgenden Beispielen für die Deklarationssyntax enthaltene Deklarator in solchen Ausdrücken als R-Wert (oder in einigen Fällen als L-Wert) verwendet werden, in denen ein einfaches Objekt vom Typ int gültig ist. Der Typ der eingebetteten Bezeichner wird folgendermaßen von deren Deklaratoren abgeleitet:
Beispiele für die Deklarationssyntax:
| Deklaratorsyntax | Implizierter Typ von Name | Beispiel |
|---|---|---|
|
type name |
type |
int count; |
|
type name[]; |
(offenes) Array von type |
int count[]; |
|
type name[3]; |
Festes Array von drei Elementen, alle vom type |
int count[3] |
|
type *name; |
Zeiger auf type |
int *count; |
|
type *name[]; |
(offenes) Array von Zeigern auf type |
int *count[]; |
|
type *(name[]); |
Siehe oben |
int *(count[]); |
|
type (*name)[]; |
Zeiger auf ein (offenes) Array von type |
int (*count) []; |
|
type &name; |
Referenz auf type (nur in C++) |
int &count; |
|
type name(); |
Funktion, die type zurückgibt |
int count(); |
|
type *name(); |
Funktion, die Zeiger auf type zurückgibt |
int *count(); |
|
type *(name()); |
Siehe oben |
int *(count()); |
|
type (*name)(); |
Zeiger auf Funktion, die type zurückgibt |
int (*count) (); |
Die Klammern in (*name)[] und (*name)() sind erforderlich, weil sowohl der Array-Deklarator [ ] als auch der Funktionsdeklarator ( ) einen höheren Rang besitzen als der Zeiger-Deklarator *. Die Klammern in *(name[]) sind nicht unbedingt erforderlich.
Anmerkung: Informationen über die Deklaratorsyntax finden Sie in der C++Builder Deklarationssyntax. Die Definition umfasst sowohl Bezeichner als auch Funktionsdeklaratoren.