C-Syntax für Funktionen, die Funktionszeiger zurückgeben

Question 1

Betrachten Sie die folgenden Typedefs:

typedef int (*f1)(float);
typedef f1 (*f2)(double);
typedef f2 (*f3)(int);

f2 ist eine Funktion, die einen Funktionszeiger zurückgibt. Das selbe mit f3sondern der Typ der Funktion, der Zeiger auf die f3 Rückkehr, ist f2. Wie kann ich definieren f3 ohne die typedefs? Ich weiß, dass Typedefs die sauberere und einfacher zu verstehende Art der Definition sind f3. Meine Absicht hier ist jedoch, die C-Syntax besser zu verstehen.

Question 2

Beginnen Sie mit Ihrer Erklärung für f1:

int (*f1)(float);

Sie wollen f2 ein Zeiger auf eine zurückkehrende Funktion sein f1also ersetzen f1 in der Erklärung oben mit der Erklärung für f2:

int (*      f1     )(float);
            |
      +-----+-----+
      |           |
      v           v
int (*(*f2)(double))(float);

Die Deklaration lautet wie

        f2                   -- f2
       *f2                   -- is a pointer
      (*f2)(      )          -- to a function
      (*f2)(double)          --   taking a double parameter
     *(*f2)(double)          --   returning a pointer
    (*(*f2)(double))(     )  --   to a function
    (*(*f2)(double))(float)  --     taking a float parameter
int (*(*f2)(double))(float)  --     returning int

Sie wiederholen den Vorgang für f3:

int (*(*    f2    )(double))(float);
            |
        +---+----+
        |        |
        v        v
int (*(*(*f3)(int))(double))(float);

was sich liest wie

          f3                           -- f3
         *f3                           -- is a pointer
        (*f3)(   )                     -- to a function
        (*f3)(int)                     --   taking an int parameter
       *(*f3)(int)                     --   returning a pointer
      (*(*f3)(int))(      )            --   to a function
      (*(*f3)(int))(double)            --     taking a double parameter
     *(*(*f3)(int))(double)            --     returning a pointer
    (*(*(*f3)(int))(double))(     )    --     to a function
    (*(*(*f3)(int))(double))(float)    --       taking a float parameter
int (*(*(*f3)(int))(double))(float);   --       returning int

Question 3

In C++ kann dies durch das Wunder der Templates etwas einfacher werden.

#include <type_traits>

std::add_pointer<
    std::add_pointer<
        std::add_pointer<
            int(float)
        >::type(double)
    >::type(int)
>::type wow;

Question 4

Dasselbe wie bei der Typedef, nur dass Sie Ihre Funktionsdefinition anstelle ihres Namens setzen.

Hier ist wie f2 würde aussehen wie:

typedef int (*(*f2)(double))(float);

Du kannst tun f3 als Übung, da ich davon ausgehe, dass es sich um eine Hausaufgabe handelt 😉

Question 5

Einfach nicht. Es kann getan werden, aber es wird sehr verwirrend sein. Typedefs sind da, um das Schreiben und Lesen dieses kurzen Codes zu erleichtern.

Eine Funktion f die keine Argumente akzeptiert und einen Funktionszeiger zurückgibt int (*)(float) wäre wahrscheinlich so etwas wie (ungetestet):

int (*f())(float);

Dann müssen Sie für den Rest nur noch Klammern hinzufügen, bis es wie Lispeln aussieht.

Question 6

Lerne das die Rechts-Links-Regel:

Die “Rechts-Links”-Regel ist eine völlig reguläre Regel zur Entschlüsselung von C-Deklarationen. Es kann auch nützlich sein, sie zu erstellen.

Question 7

Inspiriert von John Bodes Antwort möchte ich sie grafisch darstellen. Es sollte Ihnen helfen zu verstehen, wie der Compiler es in einen AST umwandeln würde:

Wir beginnen zunächst (1) mit dem gepackten Typ f3, wie durch “typedef f2 (*f3)(int);” bezeichnet. Es ist ein eigener Funktionstyp. Dann wird es einen Schritt weiter in (2) entpackt, wodurch die einschließenden geschweiften Klammern gesetzt werden, was im Wesentlichen die CFG-Erzeugung der “Ist-Funktion” der C-Sprache durchführt (ich gehe davon aus, dass der Leser eine grundlegende Vorstellung von der lexikalischen Analyse von Programmiersprachen hat). Wenn Sie sich (3) ansehen, sehen Sie, dass wir den „Ist-Funktion“-Lexierungsschritt dreimal rekursiv durchgeführt haben, wobei die drei Male durch die „Funktions“-Knoten im Diagramm sichtbar sind.

Wenn ich mich an den erforderlichen (aber vereinfachten) CFG-Produktionen in benutzerdefinierter Notation versuche, könnten sie so aussehen …

declaration -> underlying_type:specifier sp ( func-ptr-decl | specifier )
func-ptr-decl -> '(' sp '*' sp ( func-ptr-decl | specifier ) sp ')' sp '(' sp param-list sp ')'

specifier ist eine Zeichenfolge, die am besten als Variablennamen in der Programmiersprache C erklärt wird, sp ist eine optionale Zeichenfolge mit Leerzeichen, param-list vereinfacht als (möglicherweise leere) kommagetrennte Liste von Deklarationen.

In C wird jede Anweisung, die eine Variable oder einen Parameter einführt, als Deklaration bezeichnet. Deklarationen bestehen aus einem Ort/Namen, dem Typ der Daten und einem Initialisierer. In der gegebenen Frage haben wir Deklarationen, deren Typen Zeiger auf Funktionen sind. Der Zeiger-auf-Funktion-Typ ist bis zu dreimal rekursiv verschachtelt. Das Diagramm zeigt es so, wie die Pfeile auf Typen zeigen, was bedeutet, dass sie in anderen Typen verschachtelt sind.

Question 8

Verwenden std::function:

typedef std::function<int(float)> f1;
typedef std::function<f1(double)> f2;
typedef std::function<f2(int)>    f3;

oder

typedef std::function<std::function<std::function<int(float)>(double)>(int)> f3;