Wie funktioniert der C-Code, der ohne Schleifen oder bedingte Anweisungen von 1 bis 1000 druckt?

Ich habe CCode gefunden , der von 1 bis 1000 ohne Schleifen oder Bedingungen druckt : Aber ich verstehe nicht, wie es funktioniert. Kann jemand den Code durchgehen und jede Zeile erklären?

#include <stdio.h>
#include <stdlib.h>

void main(int j) {
  printf("%d\n", j);
  (&main + (&exit - &main)*(j/1000))(j+1);
}

Schreiben Sie niemals solchen Code.

Für j<1000, j/1000null (Integer - Division). So:

(&main + (&exit - &main)*(j/1000))(j+1);

ist äquivalent zu:

(&main + (&exit - &main)*0)(j+1);

Welches ist:

(&main)(j+1);

Welches ruft mainmit j+1.

Wenn j == 1000, dann kommen die gleichen Zeilen heraus wie:

(&main + (&exit - &main)*1)(j+1);

Was darauf hinausläuft

(&exit)(j+1);

Welches ist exit(j+1)und verlässt das Programm.

(&exit)(j+1)und exit(j+1)sind im Wesentlichen dasselbe - zitiert C99 §6.3.2.1 / 4:

Ein Funktionsbezeichner ist ein Ausdruck mit dem Funktionstyp. Außer wenn es sich um den Operanden des Operators sizeof oder des Operators unary & handelt , wird ein Funktionsbezeichner vom Typ " Funktionsrückgabetyp " in einen Ausdruck mit dem Typ " konvertiert". Zeiger auf den Funktionsrückgabetyp .

exitist ein Funktionsbezeichner. Auch ohne das Unäre& Adresse des Operators wird sie als Zeiger auf die Funktion behandelt. (Das &macht es nur explizit.)

Funktionsaufrufe sind in §6.5.2.2 / 1 und folgenden beschrieben:

Der Ausdruck, der die aufgerufene Funktion bezeichnet, muss einen Typzeiger auf die Funktion haben die void zurückgibt oder einen anderen Objekttyp als einen Array-Typ zurückgibt.

So exit(j+1) aufgrund der automatischen Konvertierung des Funktionstyps in einen Zeiger-zu-Funktionstyp und (&exit)(j+1)funktioniert auch mit einer expliziten Konvertierung in einen Zeiger-zu-Funktionstyp.

Abgesehen davon ist der obige Code nicht konform ( mainnimmt entweder zwei oder gar keine Argumente an) und &exit - &mainist meines Erachtens gemäß §6.5.6 / 9 undefiniert:

Wenn zwei Zeiger subtrahiert werden, zeigen beide auf Elemente desselben Array-Objekts oder einen nach dem letzten Element des Array-Objekts. ...

Die Addition (&main + ...)wäre an sich gültig und könnte verwendet werden, wenn die hinzugefügte Menge Null wäre, da in §6.5.6 / 7 Folgendes steht:

Für die Zwecke dieser Operatoren verhält sich ein Zeiger auf ein Objekt, das kein Element eines Arrays ist, genauso wie ein Zeiger auf das erste Element eines Arrays der Länge eins mit dem Objekttyp als Elementtyp.

Das Hinzufügen von Null zu &mainwäre also in Ordnung (aber nicht sehr nützlich).

Es verwendet Rekursion, Zeigerarithmetik und nutzt das Rundungsverhalten der Ganzzahldivision.

Der j/1000Begriff rundet für alle auf 0 ab j < 1000; Einmalj 1000 erreicht ist, wird 1 ausgewertet.

Wenn Sie nun haben a + (b - a) * n, wo nentweder 0 oder 1 ist, erhalten Sie aif n == 0undb if n == 1. Wenn Sie &main(die Adresse von main()) und &exitfür aund verwenden b, wird der Begriff (&main + (&exit - &main) * (j/1000))zurückgegeben, &mainwenn er junter 1000 liegt.&exit . Dem resultierenden Funktionszeiger wird dann das Argument zugeführt j+1.

Dieses ganze Konstrukt führt zu rekursivem Verhalten: Während jes unter 1000 liegt, mainruft es sich selbst rekursiv auf; Wenn j1000 erreicht ist, wird exitstattdessen aufgerufen, wodurch das Programm mit dem Exit-Code 1001 beendet wird (was etwas schmutzig ist, aber funktioniert).