¿Cómo funciona el código C que imprime de 1 a 1000 sin bucles o sentencias condicionales?

He encontrado Ccódigo que imprime de 1 a 1000 sin bucles o condicionales : pero no entiendo cómo funciona. ¿Alguien puede leer el código y explicar cada línea?

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

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

Nunca escribas código como ese.

Para j<1000, j/1000es cero (división entera). Entonces:

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

es equivalente a:

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

Cual es:

(&main)(j+1);

Que llama maincon j+1.

Si j == 1000, entonces las mismas líneas salen como:

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

Que se reduce a

(&exit)(j+1);

Que es exit(j+1)y sale del programa.

(&exit)(j+1)y exit(j+1)son esencialmente lo mismo, citando C99 §6.3.2.1 / 4:

Un designador de función es una expresión que tiene tipo de función. Excepto cuando es el operando del operador sizeof o el operador unario y , un designador de función con el tipo " tipo de retorno de función " se convierte en una expresión que tiene el tipo " puntero al tipo de retorno de función ".

exites un designador de funciones. Incluso sin la &dirección unaria del operador, se trata como un puntero para funcionar. (Lo &justo lo hace explícito).

Y las llamadas a funciones se describen en §6.5.2.2 / 1 y siguientes:

La expresión que denota la función llamada tendrá un puntero de tipo para funcionar devolviendo vacío o devolviendo un tipo de objeto que no sea un tipo de matriz.

Por lo tanto, exit(j+1)funciona debido a la conversión automática del tipo de función a un tipo de puntero a función, y (&exit)(j+1)funciona también con una conversión explícita a un tipo de puntero a función.

Dicho esto, el código anterior no es conforme ( maintoma dos argumentos o ninguno), y &exit - &maincreo que no está definido de acuerdo con §6.5.6 / 9:

Cuando se restan dos punteros, ambos apuntarán a elementos del mismo objeto de matriz , o uno más allá del último elemento del objeto de matriz; ...

La adición (&main + ...)sería válida en sí misma y podría usarse, si la cantidad agregada fuera cero, ya que §6.5.6 / 7 dice:

Para los fines de estos operadores, un puntero a un objeto que no es un elemento de una matriz se comporta igual que un puntero al primer elemento de una matriz de longitud uno con el tipo de objeto como su tipo de elemento.

Por lo tanto, agregar cero a &mainestaría bien (pero no mucho uso).

Utiliza la recursividad, la aritmética del puntero y explota el comportamiento de redondeo de la división de enteros.

El j/1000término se redondea a 0 para todos j < 1000; una vez que jalcanza 1000, se evalúa a 1.

Ahora, si tiene a + (b - a) * n, donde nes 0 o 1, terminará con aif n == 0y bif n == 1. Usando &main(la dirección de main()) y &exitpara ay b, el término (&main + (&exit - &main) * (j/1000))vuelve &maincuando jestá por debajo de 1000, de lo &exitcontrario. El puntero de función resultante se alimenta luego del argumento j+1.

Toda esta construcción da como resultado un comportamiento recursivo: mientras jestá por debajo de 1000, se mainllama recursivamente; cuando jalcanza 1000, llama en su exitlugar, haciendo que el programa salga con el código de salida 1001 (que está un poco sucio, pero funciona).