如何用C预处理器生成嵌套for循环（替代递归，深度2-10，禁用Boost）

因为你的循环深度固定在2-10之间，完全可以基于标准C预处理器手动实现嵌套循环生成，不需要依赖Boost库。核心思路是逐层定义对应深度的宏，自动嵌套循环结构，并将所有循环变量传递给最终的计算逻辑。

实现代码 #

首先定义辅助宏用于标识符连接，再分别实现深度2到10的循环宏：

// 辅助宏：用于拼接两个标识符
#define CAT(a, b) CAT_INNER(a, b)
#define CAT_INNER(a, b) a##b

// 主入口宏：根据传入的深度调用对应循环宏
#define FOR_N(n, ...) CAT(FOR_, n)(__VA_ARGS__)

// 深度2的嵌套循环
#define FOR_2(var1, bound1, var2, bound2, func) \
    for (int var1 = 0; var1 < bound1; var1++) { \
        for (int var2 = 0; var2 < bound2; var2++) { \
            func(var1, var2); \
        } \
    }

// 深度3的嵌套循环
#define FOR_3(var1, bound1, var2, bound2, var3, bound3, func) \
    for (int var1 = 0; var1 < bound1; var1++) { \
        FOR_2(var2, bound2, var3, bound3, func, var1) \
    }

// 深度4的嵌套循环
#define FOR_4(var1, b1, var2, b2, var3, b3, var4, b4, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_3(var2, b2, var3, b3, var4, b4, func, var1) \
    }

// 深度5
#define FOR_5(var1, b1, var2, b2, var3, b3, var4, b4, var5, b5, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_4(var2, b2, var3, b3, var4, b4, var5, b5, func, var1) \
    }

// 深度6
#define FOR_6(var1, b1, var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_5(var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, func, var1) \
    }

// 深度7
#define FOR_7(var1, b1, var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_6(var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, func, var1) \
    }

// 深度8
#define FOR_8(var1, b1, var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, var8, b8, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_7(var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, var8, b8, func, var1) \
    }

// 深度9
#define FOR_9(var1, b1, var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, var8, b8, var9, b9, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_8(var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, var8, b8, var9, b9, func, var1) \
    }

// 深度10
#define FOR_10(var1, b1, var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, var8, b8, var9, b9, var10, b10, func) \
    for (int var1 = 0; var1 < b1; var1++) { \
        FOR_9(var2, b2, var3, b3, var4, b4, var5, b5, var6, b6, var7, b7, var8, b8, var9, b9, var10, b10, func, var1) \
    }

用法示例 #

1. 带参数的计算函数 #

如果你的计算逻辑需要用到所有循环变量，直接传入函数名即可：

#include <stdio.h>

void compute_3(int i, int j, int k) {
    printf("i=%d, j=%d, k=%d\n", i, j, k);
}

int main() {
    // 生成深度3的嵌套循环，边界分别为2、3、4
    FOR_3(i, 2, j, 3, k, 4, compute_3);
    return 0;
}

2. 无参数的计算函数 #

如果计算逻辑不需要循环变量，用可变参数宏适配即可：

#include <stdio.h>

void do_computation() {
    printf("Running computation...\n");
}

// 适配宏：忽略所有传入的参数
#define DO_COMPUTE(...) do_computation()

int main() {
    // 生成深度2的嵌套循环
    FOR_2(x, 5, y, 5, DO_COMPUTE);
    return 0;
}

3. 动态指定循环深度 #

通过宏定义控制循环深度，用FOR_N统一调用：

#define LOOP_DEPTH 4

void compute_4(int a, int b, int c, int d) {
    // 自定义计算逻辑
}

int main() {
    FOR_N(LOOP_DEPTH, a, 2, b, 3, c, 4, d, 5, compute_4);
    return 0;
}

注意事项 #

• 每个FOR_N宏的参数顺序为：变量1, 边界1, 变量2, 边界2, ..., 变量n, 边界n, 计算函数/宏
• 计算函数/宏的参数数量需匹配循环深度，或用可变参数宏忽略多余参数
• 完全基于标准C预处理器实现，无外部依赖

内容的提问来源于stack exchange，提问作者Andrew Mathews