在C语言中，如何编写N为变量的N维嵌套for循环？

嘿，这个问题我之前也碰到过——在C里没法直接写动态N层嵌套for循环，毕竟N是变量的时候编译器没法提前解析层数。不过有两种非常实用的实现方式，我给你拆解清楚，附代码例子：

递归的思路很直观：每一层递归对应一个维度的循环，当递归到第N层时，就执行你需要的核心操作。我们用一个数组来跟踪每个维度当前的循环索引，递归过程中会自动维护这个数组的状态。

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

// 递归处理N维循环
void n_dim_recursive(int current_dim, int total_dims, int* lower_bounds, int* upper_bounds, int* indices) {
    // 递归终止条件：已经处理完所有维度，执行核心操作
    if (current_dim == total_dims) {
        // 这里替换成你实际要做的事，比如访问N维数组、计算等
        printf("当前索引组合：");
        for (int i = 0; i < total_dims; i++) {
            printf("%d ", indices[i]);
        }
        printf("\n");
        return;
    }

    // 遍历当前维度的所有可能值，递归进入下一个维度
    for (indices[current_dim] = lower_bounds[current_dim]; indices[current_dim] < upper_bounds[current_dim]; indices[current_dim]++) {
        n_dim_recursive(current_dim + 1, total_dims, lower_bounds, upper_bounds, indices);
    }
}

int main() {
    int N = 3; // 可以改成任意正整数
    int lower[] = {0, 1, 2}; // 每个维度的循环下限
    int upper[] = {2, 3, 4}; // 每个维度的循环上限（左闭右开）
    int* indices = malloc(N * sizeof(int));

    if (!indices) {
        perror("内存分配失败");
        return 1;
    }

    n_dim_recursive(0, N, lower, upper, indices);

    free(indices);
    return 0;
}

这段代码里，current_dim是当前正在处理的维度，从0开始计数。当它等于total_dims时，说明我们已经遍历到了N维循环的最内层，这时候就可以执行你的业务逻辑了。

递归虽然简单，但如果N特别大（比如上千层），会触发栈溢出。这时候迭代式方法更稳妥——我们手动维护每个维度的循环状态，像数字进位一样处理循环的“溢出”。

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

void n_dim_iterative(int total_dims, int* lower_bounds, int* upper_bounds) {
    int* indices = malloc(total_dims * sizeof(int));
    if (!indices) {
        perror("内存分配失败");
        return;
    }

    // 初始化所有维度的索引为下限
    for (int i = 0; i < total_dims; i++) {
        indices[i] = lower_bounds[i];
    }

    while (1) {
        // 执行核心操作
        printf("当前索引组合：");
        for (int i = 0; i < total_dims; i++) {
            printf("%d ", indices[i]);
        }
        printf("\n");

        // 从最内层开始处理进位
        int dim = total_dims - 1;
        while (dim >= 0) {
            indices[dim]++;
            if (indices[dim] < upper_bounds[dim]) {
                // 当前维度没到上限，停止进位
                break;
            }
            // 当前维度已到上限，重置为下限，继续向上进位
            indices[dim] = lower_bounds[dim];
            dim--;
        }

        // 如果dim < 0，说明所有维度都遍历完毕，退出循环
        if (dim < 0) {
            break;
        }
    }

    free(indices);
}

int main() {
    int N = 3;
    int lower[] = {0, 1, 2};
    int upper[] = {2, 3, 4};

    n_dim_iterative(N, lower, upper);
    return 0;
}

这个方法的逻辑类似数字的加法进位：每次先执行核心操作，然后从最内层循环开始尝试加1，如果当前维度达到上限，就重置为下限，然后往上一层维度进位，直到所有维度都遍历完成。

额外提示 #

• 两种方法都支持每个维度设置不同的上下限，灵活性拉满。
• 如果需要访问N维数组（通常用一维数组模拟），可以提前计算每个维度的步长（stride[i] = 数组总长度 / (第i维及之后维度的元素数)），然后通过总索引 = indices[0]*stride[0] + indices[1]*stride[1] + ... + indices[N-1]来定位元素。
• 递归方法的栈深度等于N，所以N过大时一定要用迭代式。

内容的提问来源于stack exchange，提问作者CAMILO HG