如果数量比较小，拿
1 2 0 0
3 5 0 0
4 6 0 0
来举例，先遍历一次，就知道一共有 2*2*2 种组合，因此伪代码就是
for( size_t i=0; i<2*2*2; ++i )
     输出 array[0][i/(2*2)],array[1][i/(2)%2],array[2][i%2]
这样就将 m*n 这种无限次循环降为有限次

如果数量庞大，在数组内做标记（需要点技巧，就不说了），自己模拟栈
这样就将 m*n 这种无限次循环降为有限次

个人还是更倾向于递归，更简洁一些。不过这里就递归和非递归分别给出例子，算法很简单，主要是交流一下功能封装的理念。

其中traversal是递归处理方式（实际算法在sub_traversal中，traversal是对sub_traversal的接口进行了简化封装），t2是非递归处理方式。

#include<stdio.h>
#include<malloc.h>

void sub_traversal(int * a, int m, int n, int * list, int deep)
{
    int i, *b;
    
    if(deep == m)
    {
        for(i = 0; i < m; printf("%d", list[i++]));
        putchar(' ');
        return;
    }
    b = a + deep * n;
    for(i = 0; i < n && (b[i] || !i); i++)
    {
        list[deep] = b[i];
        sub_traversal(a, m, n, list, deep + 1);
        if(deep == 0) puts("");
    }
}

void traversal(int * a, int m, int n)
{
    int * list;
    list = (int *)malloc(m * sizeof(int));
    if(list == NULL) return;
    sub_traversal(a, m, n, list, 0);
    free(list);
}

void t2(int * a, int m, int n)
{
    int * list, i;
    list = (int *)calloc(m, sizeof(int));
    if(list == NULL) return;
    
    while(list[0] < n && (a[list[0]] || !list[0]))
    {
        for(i = 0; i < m; i++) printf("%d", a[list[i] + n * i]);
        putchar(' ');
        for(i = m - 1; i > 0; i--)
        {
            list[i]++;
            if(list[i] >= n || !a[list[i] + n * i]) list[i] = 0; else break;
        }
        if(i == 0) list[0]++, puts("");
    }
    
    free(list);
}

int main()
{
    int a[][4] = {{1, 2}, {0, 0}, {4, 6}};
    traversal((int *)a, 3, 4);
    puts("");
    t2((int *)a, 3, 4);
    return 0;
}