Саморазворачивающийся макроцикл в C/C++

Вы можете использовать шаблоны для развертывания. См. разборку для примера Live on Godbolt

Но -funroll-loops имеет тот же эффект для этого образца.

Жить на Coliru

template <unsigned N> struct faux_unroll {
    template <typename F> static void call(F const& f) {
        f();
        faux_unroll<N-1>::call(f);
    }
};

template <> struct faux_unroll<0u> {
    template <typename F> static void call(F const&) {}
};

#include <iostream>
#include <cstdlib>

int main() {
    srand(time(0));

    double r = 0;
    faux_unroll<10>::call([&] { r += 1.0/rand(); });

    std::cout << r;
}

Вы можете использовать препроцессор и поэкспериментировать с конкатенацией токенов и расширением нескольких макросов, но вам придется жестко закодировать все возможности:

#define M_REPEAT_1(X) X
#define M_REPEAT_2(X) X X
#define M_REPEAT_3(X) X X X
#define M_REPEAT_4(X) X X X X
#define M_REPEAT_5(X) X M_REPEAT_4(X)
#define M_REPEAT_6(X) M_REPEAT_3(X) M_REPEAT_3(X)

#define M_EXPAND(...) __VA_ARGS__

#define M_REPEAT__(N, X) M_EXPAND(M_REPEAT_ ## N)(X)
#define M_REPEAT_(N, X) M_REPEAT__(N, X)
#define M_REPEAT(N, X) M_REPEAT_(M_EXPAND(N), X)

А затем расширить его следующим образом:

#define THREE 3

M_REPEAT(THREE, three();)
M_REPEAT(4, four();)
M_REPEAT(5, five();)
M_REPEAT(6, six();)

Этот метод требует буквальных чисел в качестве счетчиков, вы не можете сделать что-то вроде этого:

#define COUNT (N + 1)

M_REPEAT(COUNT, stuff();)

Стандартного способа сделать это нет.

Вот немного чокнутый подход:

#define DO_THING printf("Shake it, Baby\n")
#define DO_THING_2 DO_THING; DO_THING
#define DO_THING_4 DO_THING_2; DO_THING_2
#define DO_THING_8 DO_THING_4; DO_THING_4
#define DO_THING_16 DO_THING_8; DO_THING_8
//And so on. Max loop size increases exponentially. But so does code size if you use them. 

void do_thing_25_times(void){
    //Binary for 25 is 11001
    DO_THING_16;//ONE
    DO_THING_8;//ONE
    //ZERO
    //ZERO
    DO_THING;//ONE
}

Не так уж много можно попросить оптимизатора устранить мертвый код. В таком случае:

#define DO_THING_N(N) if(((N)&1)!=0){DO_THING;}\
    if(((N)&2)!=0){DO_THING_2;}\
    if(((N)&4)!=0){DO_THING_4;}\
    if(((N)&8)!=0){DO_THING_8;}\
    if(((N)&16)!=0){DO_THING_16;}

Вы не можете использовать конструкцию #define для вычисления «счетчика развертывания». Но с достаточным количеством макросов вы можете определить это:

#define LOOP1(a) a
#define LOOP2(a) a LOOP1(a)
#define LOOP3(a) a LOOP2(a)

#define LOOPN(n,a) LOOP##n(a)

int main(void)
{
    LOOPN(3,printf("hello,world"););
}

_{Протестировано с VC2012}

Вы не можете писать настоящие рекурсивные инструкции с макросами, и я почти уверен, что вы не можете иметь настоящую итерацию в макросах.

Однако вы можете взглянуть на Порядок. Хотя он полностью построен на основе препроцессора C, он «реализует» функции, подобные итерациям. На самом деле он может иметь до N итераций, где N — некоторое большое число. Я предполагаю, что это похоже на «рекурсивные» макросы. В любом случае, это настолько пограничный случай, что немногие компиляторы его поддерживают (хотя GCC — один из них).