char * const * (*foo[5])(int **p);

auf Anhieb richtig lesen kannst, dann geh zurück zur vorhergehenden Seite und such Dir ein neues Thema, oder verbesser die Ausführungen hier.

Obige Deklaration ließe sich auf verschiedene Arten interpretieren, die Frage ist hier aber natürlich, wie interpretiert sie der Compiler. Um zu verstehen wie man diese Deklaration lesen sollte, muß man sich vorher ansehen welche Operatoren hier verwendet werden. Eine weitere Schwierigkeit für Neulinge schleicht sich an dieser Stelle ein. Hier wird ausgerechnet ein Operator verwendet der an anderer Stelle im einem Programm auch andere Funktionalität hat. Der * Operator erzeugt an dieser Stelle wie es bekannt sein sollte einen Zeiger auf ein Objekt on einem bestimmten Typ.

Was muß man noch unterscheiden? Es gibt Klammern die eine Deklaration gruppieren, so wie das in echtem Code auch der Fall ist und es gibt Klammer die Anzeigen, daß es sich bei diesem Symbol um eine Funktion handelt. Alle Operatoren die in Deklarationen verwendet werden, sind nach der Reihenfolge Ihrer Priorität abzuarbeiten. Die Priorität (im englischen precedence) aller Operatoren ist in jedem guten C Buch abgedruckt. Hier nur in Kürze für alle in Declarationen verwendeten Operatoren:

1. Klammern die Deklarationen gruppieren
2. Die Postfix-Operatoren ( ) und [ ] für Funktions- und Felddeklarationen die von links nach recht gelesen werden
3. Der Präfix-Operator * der einen Zeiger deklariert und von rechts nach links gelesen wird

• Zuerst findet man den Namen des Symbols das deklariert wird.
• Danach liest man in oben beschriebener Reihenfolge die Opertoren
• Findet man ein const oder volatile Schlüsselwort, das direkt bei einem elementaren Datentype steht (links oder rechts), so wendet man es auf den Datentype an. Sonst wendet man es auf den links daneben stehenden Zeiger an.

char * const * (*foo[5])(int **p);

1. Ich suche mir den Namen des Symbols. Ganz eindeutig foo
2. Ich sehe foo steht zusammen mit anderen deklarierenden Zeichen zwischen zwei Klammern. Innerhalb der Klammern lese ich,
1. foo ist ein Feld von 5
2. Zeigern auf
3. wieder außerhalb der Klammern angelangt nehme ich wieder zuerst die Postfix-Operatoren und sehe eine Funktion die einen Parameter von Type Zeiger auf Zeiger auf int erwartet und
4. Und dann die Präfix-Operatoren von rechts, einen Zeiger
5. auf einen Zeiger, da jetzt aber gleich rechts daneben ein const steht einen const-Zeiger
6. auf char zurückgibt.

Hier noch ein paar zum Üben und Zähne ausbeißen:

const int * const bar[3]; int *(*baz)[10][2]; void (*signal(int sig, void (*func)(int)))(int);

Zu guter Letzt sei hier noch der Hinweis auf das Unix Utility cdecl angeführt. Mit diesem Programm kann man solche Deklarationen leicht lesen aber auch selbst leicht erzeugen, vorausgesetzt man ist in der Lage die Deklaration in englisch zu formulieren.

-- ZoranCutura

Ich möchte hier mal einen Beitrag von Niklas Matthies aus de.comp.lang.iso-c++ zu dem Thema zitieren und zur Diskussion stellen, da sein Ansatz für mich einfacher/verständlicher wirkt:

"Die Deklarationen sind nicht so schwierig zu lesen, es gilt eine einfache rechts-vor-links-Regel: d. h. man geht, ausgehend vom deklarierten Namen, grundsätzlich erstmal nach rechts. Wenn man auf eine schließende Klammer oder das Ende der Deklaration trifft, macht man nach links weiter. Wenn man dabei auf eine öffnende Klammer trifft macht man wieder nach rechts bei der entsprechenden schließenden Klammer weiter. Dabei zählt man einfach alles auf, was man antrifft, und bekommt dabei eine natürlichsprachige Beschreibung des Typs. Beispiel:

int (*x)[4];

Wir fangen beim `x' an:

             "x ist ein "

             "Pointer auf ein "

             "Array von 4 "

             "int"

             "x ist ein Pointer auf ein Array von 4 int"

int *x[4];

             x        "x ist ein "
             x[4]     "Array von 4 "
            *x[4];    "Pointer auf ein "
        int *x[4];    "int"

void *x(int *(*)[], int (*(*)[5])(int*));

              x                                   "x ist eine "
              x(                                  "Funktion mit Parametern ("
              x(      *                           "Pointer auf "
              x(     (*)[]                        "Array von "
              x(    *(*)[]                        "Pointern auf "
              x(int *(*)[],                       "int, "
              x(int *(*)[],        *              "Pointer auf "
              x(int *(*)[],       (*)[5]          "Array von 5 "
              x(int *(*)[],      *(*)[5])         "Pointern auf "
              x(int *(*)[],     (*(*)[5])(        "Funktion mit Parametern ("
              x(int *(*)[],     (*(*)[5])(   *    "Pointer auf "
              x(int *(*)[],     (*(*)[5])(int*)   "int) "
              x(int *(*)[], int (*(*)[5])(int*))  "und Rückgabetyp int) "
             *x(int *(*)[], int (*(*)[5])(int*))  "und Rückgabetyp Pointer auf "
        void *x(int *(*)[], int (*(*)[5])(int*)); "void"

Der rechts-vor-links-Regel sollte dadurch Folge geleistet sein sein, daß man ja zuerst die Postfix-Operatoren bearbeitet. In "deiner" Version vermisse ich eine wichtige Sache, naehmlich die Assoziativität bei Deklarationen von Feldern oder Pointern. Es sollte für den Lesenden wichtig sein ob

char * const * p;

ein Zeiger auf einen const-Zeiger auf auf char ist, oder ein const-Zeiger auf einen Zeiger auf char. Darauf sollte noch irgendwie hingewiesen werden.

Gleiches gilt fuer:

char * pf[10][2];

--zc

Jetzt mit "das weiß man doch" zu argumentieren, ist wohl keine so gute Idee ;) Im ersten Fall hilft aber rechts-vor-links, da man soherum * - const * - char liest, also richtig. Probematisch ist das höchstens bei einem "abnormalen" const am Anfang der Deklaration. Warum "gleiches" auch für den zweiten Fall gelten soll, ist mir unklar. -- cd

Naja, heißt obige Deklaration nun Feld von 10 Feldern von 2 Zeigern auf char, oder Feld von 2 Feldern auf 10 Zeiger auf char. Da hier aber die meissten ganz automatisch von links nach rechts lesen, gibt das selten Probleme. Wenn man darüber nachdenkt, kommt man hoffentlich sowieso irgendwann zu Frage der Assoziativität.

Wie Du selbst sagst ist folgendes Konstrukt ebenfalls denkbar:

char const * const *p; const char * const *q;

Hier sind beide Deklarationen gleichbedeutend, können aber durchaus falsch interpretiert werden. --zc

Möglicherweise haben diverse Leute diese Regeln aus meiner c.htm gelernt, nämlich nachdem die etwa 1000 Zugriffe hatte, tauchten überall diese Erklärungen auf, die meinen Erklärungen in c.htm sehr ähnlich sind und gleiche prägnante und kennzeichnende Formulierungen verwenden. --hs

Helmut, ich habe dein Tutorial oder wie Du es nennen möchtest bis heute noch nicht gelesen und kann deshalb behaupten hier keine deiner prägnanten und kennzeichnenden Formulierungen zu verwenden. Meine Zusammenfassung stammt weitestgehend aus Peter van der Linden's "Expert C Programming". Wenn auch nicht so vollständig wie bei Peter. --zc

Ich meine das auch nicht vorwurfsvoll - ist nur eine Feststellung...