Anonyme Funktionen, die GCC-Anweisungsausdrücke verwenden

Diese Frage ist nicht sehr spezifisch; Es ist wirklich für meine eigene C-Anreicherung und ich hoffe, dass andere es auch nützlich finden können.

Haftungsausschluss: Ich weiß, dass viele den Impuls haben werden, mit “wenn Sie versuchen, FP zu machen, dann verwenden Sie einfach eine funktionale Sprache” zu antworten. Ich arbeite in einer eingebetteten Umgebung, die mit vielen anderen C-Bibliotheken verknüpft werden muss und nicht viel Platz für viele weitere große gemeinsam genutzte Bibliotheken hat und viele Sprachlaufzeiten nicht unterstützt. Außerdem kommt eine dynamische Speicherallokation nicht in Frage. Ich bin auch einfach nur neugierig.

Viele von uns haben dieses raffinierte C-Makro für Lambda-Ausdrücke gesehen:

#define lambda(return_type, function_body) \
({ \
      return_type __fn__ function_body \
          __fn__; \
})

Und ein Beispiel für die Verwendung ist:

int (*max)(int, int) = lambda (int, (int x, int y) { return x > y ? x : y; });
max(4, 5); // Example

Verwenden gcc -std=c89 -E test.cerweitert sich das Lambda zu:

int (*max)(int, int) = ({ int __fn__ (int x, int y) { return x > y ? x : y; } __fn__; });

Also, das sind meine Fragen:

1. Was genau bedeutet die Linie Ganzzahl (*X); erklären? Na sicher, Ganzzahl * X; ist ein Zeiger auf eine Ganzzahl, aber wie unterscheiden sich diese beiden?

2. Schauen Sie sich das erweiterte Makro an, was in aller Welt macht das Finale __fn__ tun? Wenn ich eine Testfunktion schreibe void test() { printf("hello"); } test; – das wirft sofort einen Fehler. Ich verstehe diese Syntax nicht.

3. Was bedeutet das für das Debuggen? (Ich habe vor, selbst damit und mit gdb zu experimentieren, aber die Erfahrungen oder Meinungen anderer wären großartig). Würde dies statische Analysatoren vermasseln?

Diese Deklaration (im Blockbereich):

int (*max)(int, int) =
    ({
    int __fn__ (int x, int y) { return x > y ? x : y; }
    __fn__;
    });

ist nicht C, aber gültiges GNU C.

Es nutzt zwei gcc Erweiterungen:

1. verschachtelte Funktionen
2. Anweisungsausdrücke

Beide verschachtelte Funktionen (Definieren einer Funktion innerhalb einer zusammengesetzten Anweisung) und Anweisungsausdrücke (({})im Grunde ein Block, der einen Wert liefert) sind in C nicht erlaubt und stammen von GNU C.

In einem Anweisungsausdruck ist die letzte Ausdrucksanweisung der Wert des Konstrukts. Deshalb die verschachtelte Funktion __fn__ erscheint als Ausdrucksanweisung am Ende des Anweisungsausdrucks. Ein Funktionsbezeichner (__fn__ in der letzten Ausdrucksanweisung) in einem Ausdruck wird durch die üblichen Konvertierungen in einen Zeiger auf eine Funktion umgewandelt. Dies ist der Wert, der zum Initialisieren des Funktionszeigers verwendet wird max.

Ihr Lambda-Makro nutzt zwei unkonventionelle Funktionen. Zuerst verwendet es tatsächlich verschachtelte Funktionen definieren den Körper Ihrer Funktion (Ihr Lambda ist also nicht wirklich anonym, es verwendet nur eine implizite __fn__ Variable (die in etwas anderes umbenannt werden sollte, da Namen mit doppelt führenden Unterstrichen für den Compiler reserviert sind, also vielleicht so etwas wie yourapp__fn__ wäre besser).

All dies wird selbst innerhalb einer zusammengesetzten GCC-Anweisung durchgeführt (siehe http://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html#Statement-Exprs), dessen Grundformat ungefähr so ​​lautet:

({ ...; retval; })

die letzte Anweisung der zusammengesetzten Anweisung ist die Adresse der gerade deklarierten Funktion. Jetzt, int (*max)(int,int) bekommt einfach den Wert der zusammengesetzten Anweisung zugewiesen, die nun der Zeiger auf die gerade deklarierte ‘anonyme’ Funktion ist.

Das Debuggen von Makros ist natürlich eine königliche Qual.

Was den Grund angeht test; .. zumindest hier bekomme ich den ‘Test als andere Art von Symbol neu deklariert’, was meiner Meinung nach bedeutet, dass GCC ihn als Deklaration und nicht als (nutzlosen) Ausdruck behandelt. Da nicht typisierte Variablen standardmäßig auf int und weil Sie bereits erklärt haben test als Funktion (im Wesentlichen void (*)(void)) du verstehst das.. aber da könnte ich mich irren.

Dies ist jedoch bei weitem nicht tragbar.

Teilantwort: Sie interessieren sich nicht für int(*X), sondern für int(*X)(y,z). Das ist ein Funktionszeiger auf die Funktion namens X, die (y,z) nimmt und int zurückgibt.

Für das Debuggen wird dies wirklich schwierig. Die meisten Debugger können Makros nicht verfolgen. Sie müssten höchstwahrscheinlich die Assembly debuggen.

1. int (*max)(int, int) ist der Variablentyp, den Sie deklarieren. Es ist als ein Funktionszeiger namens max definiert, der int zurückgibt und zwei ints als Parameter akzeptiert.

2. __fn__ bezieht sich auf den Funktionsnamen, der in diesem Fall max.

3. Da habe ich keine Antwort. Ich würde mir vorstellen, dass Sie es durchlaufen können, wenn Sie es durch den Präprozessor ausgeführt haben.