Как работает код C, который печатает от 1 до 1000 без циклов или условных операторов?

Я нашел Cкод, который печатает от 1 до 1000 без циклов или условных выражений : но я не понимаю, как это работает. Может кто-нибудь пройти код и объяснить каждую строку?

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

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

Никогда не пишите такой код.

For j<1000, j/1000это ноль (целочисленное деление). Так:

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

эквивалентно:

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

Который:

(&main)(j+1);

Какие звонки mainсj+1 .

Если j == 1000, то получаются те же строки, что и:

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

Который сводится к

(&exit)(j+1);

Который есть exit(j+1)и выходит из программы.

(&exit)(j+1)и exit(j+1)по сути одно и то же - цитируя C99 §6.3.2.1 / 4:

Обозначение функции - это выражение с типом функции. За исключением случаев, когда это операнд оператора sizeof или унарный оператор & , указатель функции с типом « тип, возвращающий функцию » преобразуется в выражение, имеющее тип « указатель на тип, возвращающий функцию ».

exitобозначение функции Даже без унарного &оператора адресации он рассматривается как указатель на функцию. ( &Просто делает это явным.)

А вызовы функций описаны в §6.5.2.2 / 1 и следующие:

Выражение, которое обозначает вызываемую функцию, должно иметь указатель типа на функцию, возвращающую void или возвращающую тип объекта, отличный от типа массива.

Так exit(j+1)работает из-за автоматического преобразования типа функции в тип указателя на функцию, а также (&exit)(j+1)работает с явным преобразованием в тип указателя на функцию.

Тем не менее, приведенный выше код не соответствует ( mainпринимает либо два аргумента, либо ни одного вообще) и &exit - &main, я полагаю, не определен в соответствии с §6.5.6 / 9:

Когда вычтены два указателя, оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива; ...

Добавление (&main + ...)будет действительным само по себе и может быть использовано, если добавленное количество будет равно нулю, поскольку в п. 6.5.6 / 7 говорится:

Для целей этих операторов указатель на объект, который не является элементом массива, ведет себя так же, как указатель на первый элемент массива длиной один с типом объекта в качестве его типа элемента.

Таким образом, добавление нуля к &mainбудет в порядке (но не очень полезно).

Он использует рекурсию, арифметику указателей и использует поведение округления целочисленного деления.

В j/1000перспективе округляется до 0 для всех j < 1000; однажды jдостигает 1000, это оценивает к 1.

Теперь, если у вас есть a + (b - a) * n, где n0 или 1, вы в конечном итоге с aif n == 0и bif n == 1. Используя &main(адрес main()) и &exitдля aи b, термин (&main + (&exit - &main) * (j/1000))возвращается, &mainкогда значение jменьше 1000, в &exitпротивном случае. Полученный указатель на функцию затем передается аргументj+1 .

Вся эта конструкция приводит к рекурсивному поведению: пока jона меньше 1000, mainрекурсивно вызывает себя; когда jдостигает 1000, он вызывает exitвместо этого, вызывая выход из программы с кодом завершения 1001 (что немного грязно, но работает).