Complex declarations

Raptor

In einer komplexen Deklaration soll man von dem Bezeichner sich vorarbeiten, bis alle Operatoren augeloest sind.

int (*x[])();

   1. x[] ist ein Array
   2. *x[] ist ein Array von Zeigern
   3. (*x[])() ist ein Array von Zeigern auf Funktionen
   4. int (*x[])() ist ein Array von Zeigern auf Funktionen, die int returnen

Was ist aber, wenn 2 Bezeichner in der Deklaration sind?

void PassPtr(int (*pt2Func)(float, char, char))

oder auch

float (*GetPtr1(const char opCode))(float, float)

Bashar

Raptor schrieb:

Was ist aber, wenn 2 Bezeichner in der Deklaration sind?
void PassPtr(int (*pt2Func)(float, char, char))
oder auch
float (*GetPtr1(const char opCode))(float, float)

PassPtr ist eine void-Funktion, deren Argument ein Zeiger auf eine Funktion ist, die eine (float, char, char)-Argumentliste erwartet und int zurückgibt.

GetPtr1 ist eine Funktion mit einem char-Argument, die einen Zeiger auf eine Funktion zurückliefert, die (float, float) erwartet und float zurückgibt.

Hilft das oder brauchst du den exakten Algorithmus?

float (*GetPtr1(const char opCode))(float, float)

lol, wer braucht denn sowas ???

Raptor

Ja, das weiss ich inzwischen auch ,
aber gibt es eine Regel, nach der man Komplexe Deklarationen mit 2 oder mehreren Bezeichnern aufloest?
Oft sind sie ja nicht so einfach zu erfassen, wie diese beiden.

Raptor

@omg: Jetzt lol hier mal nicht so rum , schau dir mal www.function-pointer.de an, dann siehst du, dass so etwas durchaus Sinn machen kann.
edit: @Bashar: ah,ja.. bitte deinen algorithmus, mit dem du das aufgeloest hast.

Shlo

Raptor schrieb:

@omg: Jetzt lol hier mal nicht so rum , schau dir mal www.function-pointer.de an, dann siehst du, dass so etwas durchaus Sinn machen kann.

Ich glaube nicht, dass er den Sinn von FP's in Frage gestellt hat, sondern er wollte mit seinem Beitrag ausdrücken, dass man solche Konstruktionen mit einem typedef umgehen sollte.

Bashar

Raptor: Eigentlich ganz normal parsen, wie ein Ausdruck, dann den entstehenden Baum analysieren ... das Problem liegt jedenfalls nicht darin, dass dort mehrere Bezeichner vorkommen, die syntaktische Struktur sagt einem schon, was der Bezeichner ist:

float (*GetPtr1(const char opCode))(float, float)

           +
          / \
         /   \
  ,------     ------------------,
  |                             |
float                           +
                               / \
                              /   \
                             /     \
                            /   (float, float)
                         --+--      ...
                        /  |  \
                       /   |   \
                      (    |    )   
                           |
                           +
                          / \
                         /   \
                        *     \ 
                               +
                               |
                               +
                              / \
                             /   \
                        GetPtr1  (const char opCode)
                                         ...

Beim Parsen bietet IMO sich aufgrund der Linksrekursion, z.B. in:

direct-declarator:
                  declarator-id
                  direct-declarator ( parameter-declaration-clause ) cv-qualifier-seqopt exception-specificationopt
                  direct-declarator [ constant-expressionopt ]
                  ( declarator )

ein Bottom-Up-Parser, z.B. von Yacc bzw. Bison erzeugt, an.