Interpretieren von komplexeren Deklaratoren
Sie können einen beliebigen Deklarator in Klammern eingeschlossen werden, um eine bestimmte Interpretation eines „komplexen Deklarators“ anzugeben. Ein komplexer Deklarator ist ein Bezeichner, der mehr als ein Array, Zeiger oder Funktion modifizierer qualifiziert wird.Sie können verschiedene Kombinationen von Arrays, des Zeigers und der Funktion modifizierer auf einen einzelnen Bezeichner gültig sind.Im Allgemeinen typedef kann verwendet werden, um Deklarationen zu vereinfachen.Weitere Informationen finden Sie unter Typedef-Deklarationen.
Wenn es komplexe Deklaratoren Klammern und Klammern interpretieren, verfügen (das heißt Modifizierer auf der rechten Seite des Bezeichners) Vorrang vor Sternchen (das heißt Modifizierer auf der linken Seite des Bezeichners).Klammern und Klammern haben den gleichen Rang und von links nach rechts angeordnet werden.Nachdem der Deklarator vollständig interpretiert worden ist, wird der Typspezifizierer während der letzten Schritt übernommen.Indem Sie Klammern verwenden, können Sie die Reihenfolge der Zuordnung überschreiben und eine bestimmte Interpretation erzwingen.Verwenden Sie niemals Klammern, um einen Bezeichnernamen.Dies könnte als Parameterliste fehlinterpretiert werden.
Eine einfache Möglichkeit, komplexe Deklaratoren zu interpretieren ist dies „,“ mithilfe der folgenden vier Schritte innerhalb von zu lesen:
Beginnen Sie mit dem Bezeichner direkt nach rechts und durchsuchen Klammern oder Klammern (sofern vorhanden).
Interpretieren dieser Klammern oder Klammern, und suchen Sie nach links nach Sternchen.
Wenn Sie eine rechte eckige Klammer zu einem beliebigen Zeitpunkt feststellen, zurückgehen und Regeln gelten für alle 1 und 2 in Klammern an.
Wenden Sie den Typspezifizierer.
char *( *(*var)() )[10]; ^ ^ ^ ^ ^ ^ ^ 7 6 4 2 1 3 5
In diesem Beispiel werden die Schritte in der Reihenfolge nummeriert und kann wie folgt interpretiert werden:
Der Bezeichner var wird als deklariert
Ein Zeiger auf
Funktion zurückkehren
Ein Zeiger auf
Ein Array mit 10 Elementen sind
Zeiger auf
char-Werte.
Beispiele
Die folgenden Beispiele veranschaulichen andere komplexe Deklarationen und zeigen, z. B. die Wichtigkeit einer Deklaration beeinflussen können.
int *var[5]; /* Array of pointers to int values */
Das Array modifizierer hat prioritärerer als Zeiger modifizierer, daher wird var deklariert, um ein Array zu sein.Der Zeiger modifizierer gilt für den Typ der Arrayelemente. Daher sind die Arrayelemente Zeiger auf int-Werten.
int (*var)[5]; /* Pointer to array of int values */
In dieser Deklaration für varKlammern geben den Zeiger modifizierer, der als Array modifizierer prioritärer ist, und var wird deklariert, um einen Zeiger auf ein Array von fünf Werten int .
long *var( long, long ); /* Function returning pointer to long */
func modifizierer verfügen auch über höhere Priorität als Zeiger modifizierer deklariert, sodass diese Deklaration für varvar , um eine Funktion sein, die einen Zeiger auf einen long-Wert zurückgibt.Die Funktion wurde deklariert, um zwei long-Werte als Argumente annehmen.
long (*var)( long, long ); /* Pointer to function returning long */
Dieses Beispiel entspricht dem vorherigen ähnlich.Klammern geben den Zeiger modifizierer, der als Funktion modifizierer prioritärer ist, und var wird deklariert, um ein Zeiger auf eine Funktion, die einen long-Wert zurückgibt.Auch die Funktion akzeptiert zwei Argumente long .
struct both /* Array of pointers to functions */
{ /* returning structures */
int a;
char b;
} ( *var[5] )( struct both, struct both );
Die Elemente eines Arrays können keine Funktionen sein, doch diese Deklaration wird veranschaulicht, wie ein Array von Zeigern auf Funktionen stattdessen deklariert.In diesem Beispiel wird var deklariert, um ein Array mit fünf Zeiger auf Funktionen, die strukturen mit zwei Member.Die Argumente für Funktionen werden deklariert, um zwei Strukturen mit denselben Strukturtyp, bothsein.Beachten Sie, dass die Klammern, die *var[5] umgeben, erforderlich sind.Ohne diese Deklaration wird ein ungültiger Versuch, ein Array von Funktionen zu deklarieren, wie im Folgenden dargestellt:
/* ILLEGAL */
struct both *var[5]( struct both, struct both );
Die folgende Anweisung deklariert ein Array von Zeigern.
unsigned int *(* const *name[5][10] ) ( void );
Das name Array mit 50 Elementen in einem mehrdimensionalen Feld organisiert werden.Die Elemente sind Zeiger auf einen Zeiger, der eine Konstante ist.Dieser konstante Zeiger zeigt auf eine Funktion, die keine Parameter verfügt und einen Zeiger auf einen Typ ohne Vorzeichen zurück.
Das folgende Beispiel ist eine Funktion, die einen Zeiger auf ein Array von drei doub-Werten zurückgibt.
double ( *var( double (*)[3] ) )[3];
In dieser Deklaration einer Funktion gibt einen Zeiger auf ein Array zurück, da die Funktionen, die Arrays zurückgeben, ungültig sind.Hier wird var deklariert, um eine Funktion sein, die einen Zeiger auf ein Array von drei doub-Werten zurückgibt.Die Funktion var übernimmt ein Argument.Das Argument, wie der Rückgabewert ist ein Zeiger auf ein Array von drei doub-Werten.Der Argumenttyp ist durch einen abstraktenkomplexen Deklaratorangegeben.Die Klammern um das Sternchen im Argumenttyp sind erforderlich. ohne sie würde der Argumenttyp ein Array von drei Zeiger auf die doub-Werten sein.Ausführliche Informationen und Beispiele finden Sie unter Deklaratoren abstrakten Abstrakte Deklaratoren.
union sign /* Array of arrays of pointers */
{ /* to pointers to unions */
int x;
unsigned y;
} **var[5][5];
Wie im obigen Beispiel gezeigt, kann ein Zeiger auf einen anderen Zeiger wird, und ein Array von Arrays können als Elemente enthalten.In diesem Fall ist var ein Array mit fünf Elemente.Jedes Element ist ein Zeiger auf ELEMENT-Array fünf Zeiger auf den Unions mit zwei Member.
union sign *(*var[5])[5]; /* Array of pointers to arrays
of pointers to unions */
Dieses Beispiel zeigt, wie die Platzierung von Klammern die Bedeutung der Deklaration ändert.In diesem Beispiel ist ein var fünf ELEMENT-Array fünf Zeiger auf ELEMENT-Arrays Zeigern zu Unions.Beispiele, wie typedef verwendet, um komplexe Deklarationen zu vermeiden, finden Sie unter Typedef-Deklarationen.