C++ 如何将包含3个嵌套循环的函数转换为一个递归函数？

以下函数的递归版本是什么样的：

void tri_loop(size_t i, size_t j, size_t k)
{
    for(size_t x = 0; x < i; ++x)
        for(size_t y = 0; y < j; ++y)
            for(size_t z = 0; z < k; ++z)
            {
                cout << x <<y << z;
            }
}

void tri_循环（大小i、大小j、大小k）
{
对于（尺寸x=0；xcout我能想到的最简单的方法是将它分成四个函数，如下所示：

void tri_loop(size_t j, size_t k, size_t K) {
    tri_loopX(0,i,j,k);
}

void tri_loopX(size_t x, size_t i, size_t j, size_t k) {
    if (x >= i) {
        return;
    } else {
        tri_loopY(x, 0, j, k);
        tri_loopX(++x, i, j, k);
    }
}

void tri_loopY(size_t x, size_t y, size_t j, size_t k) {
    if (y >= j) {
        return;
    } else {
         tri_loopZ(x, y, 0, k);
         tri_loopY(x, ++y, j, k); 
    }
}

void tri_loopZ(size_t x, size_t y, size_t z, size_t k) {
    if (z >= k) {
        return;
    } else {
        cout << x << y << z;
        tri_loopZ(x, y, ++z, k);
    }
}

void tri_循环（大小j、大小k、大小k）{
tri_-loopX（0，i，j，k）；
}
void tri_loopX（尺寸x、尺寸i、尺寸j、尺寸k）{
如果（x>=i）{
返回；
}否则{
三环（x，0，j，k）；
tri_loopX（++x，i，j，k）；
}
}
void tri_loopY（大小x、大小y、大小j、大小k）{
如果（y>=j）{
返回；
}否则{
三次环z（x，y，0，k）；
三环（x，++y，j，k）；
}
}
void tri_loopZ（大小x、大小y、大小z、大小k）{
如果（z>=k）{
返回；
}否则{
我可以这样想：

void tri_loop_work(size_t i, size_t imax, size_t j, size_t jmax, size_t k, size_t kmax)
{
  std::cout << "i=" << i << ", j=" << j << ", k=" << k << std::endl;
  if(k < kmax)
    tri_loop_work(i, imax, j, jmax, k + 1, kmax);
  else if(j < jmax)
    tri_loop_work(i, imax, j + 1, jmax, 0, kmax);
  else if(i < imax)
    tri_loop_work(i + 1, imax, 0, jmax, 0, kmax);
}

void tri_loop(size_t imax, size_t jmax, size_t kmax)
{
  tri_loop_work(0, imax, 0, jmax, 0, kmax);
}

void tri_loop_工作（大小i、大小imax、大小j、大小jmax、大小k、大小kmax）
{
std:：cout就堆栈空间而言，第一个版本比在递归调用之间传递所有变量的naive方法要有效得多（事实上，您应该能够计算3倍的深度（如果您能够找出原因的话）

使用GCC：

#include <stdio.h>

void tri_loop(size_t ii, size_t jj, size_t kk)
{
  void tri_loop_inner(size_t i, size_t j, size_t k)
  {
    printf("i=%d j=%d k=%d \n", i, j, k);

    if(k < kk)
        tri_loop_inner(i,j,k+1);
    else if(j < jj)
        tri_loop_inner(i,j+1,0);
    else if(i < ii)
        tri_loop_inner(i+1,0,0);
  }

  tri_loop_inner(0, 0, 0);
}

int main()
{

        tri_loop(3,3,3);
        return 0;
}

#包括
无效三环（尺寸ii、尺寸jj、尺寸kk）
{
空心三环路（尺寸i、尺寸j、尺寸k）
{
printf（“i=%dj=%dk=%d\n”，i，j，k）；
if（k

这不是C++，它甚至不是正确的C，但是自从我看到unFunt的回答以来，它一直困扰着我。
 <代码>空洞递归（累加器，B，C，D，极限）
void recurse(accumulator,b,c,d,limit)
{
  if (limit == 0)
    printf("%i %i %i\n", b, c, d);
  else
    if (accumulator<limit)
    {
      recurse(accumulator+1,b,c,d,limit);
      recurse(0,accumulator,b,c,d);
    }
}

main()
{
  int x=2,y=3,z=4;
  recurse(0,0,x,y,z);
}

{
如果（限制==0）
printf（“%i%i%i\n”，b、c、d）；
其他的
如果（acculator我想写一个类，只是为了减少参数列表的数量

class tri_loop_tool
{
  private:
    size_t x, y, z;
    size_t i, j, k;

    void Over_z ();
    void Over_y ();
    void Over_x ();

  public:
    void operator() (size_t pi, pj, pk);
};

void tri_loop_tool::Over_z ()
{
  if (z < k)
  {
    cout << x << ", " << y << ", " << z << endl;
    z++;    Over_z ();
  }
}

void tri_loop_tool::Over_y ()
{
  if (y < j)
  {
    z = 0;  Over_z ();
    y++;    Over_y ();
  }
}

void tri_loop_tool::Over_x ()
{
  if (x < i)
  {
    y = 0;  Over_y ();
    x++;    Over_x ();
  }
}

void tri_loop_tool::operator() (size_t pi, pj, pk)
{
  i = pi; j = pj; k = pk;
  x = 0;  Over_x ();
}

class tri\u loop\u工具
{
私人：
尺寸x，y，z；
尺寸i，j，k；
在_z（）上无效；
在_y（）上无效；
在_x（）上无效；
公众：
void运算符（）；
};
void tri_loop_tool:：Over_z（）
{
if（z为什么现在每个人都使用size\u t而不是旧的（和更短的）in？我的第一个想法是，使这个函数递归将引入静态变量和更多的代码（if语句等）。似乎这个函数可以更好地设计为三个嵌套循环。因为cout是这里唯一使用的C++特定功能，所以也可以将其标记为C。@reinier：在这个具体的例子中：从所示的代码中，我会使用
unsigned int
——除非参数传递（可能是由于代码某些部分的限制，我们没有显示）是
size\u t
（实际上是
std:：size\u t
）一般来说：当访问数组时，代码> STD:：SiZeSt只是应该使用的类型。我猜STL无处不在的代码> SiZeYHype 让人们意识到这一点。我仍然感觉到紧张。C++中有人做某事的主要原因是结果很快，否则为什么没有。无论如何，速度是你的事情，你必须事先知道数据类型（比如int的大小、char的大小等等），否则你最终会经历循环，使代码尽可能可移植（从而牺牲速度）.size_t感觉像是另一种数据类型，其大小未知且可能是为了可移植性，因此牺牲了速度。因此，速度与可移植性是我在这里感受到的紧张关系。如果这真的有效，那么对大多数人来说都是加分。使用gcc编译很好。我的函数采用了一些可疑的捷径键入-如果你的编译器抱怨，在参数列表中添加int。我测试了它，它工作了！你确实在我的脑袋上钻了一个大洞。
void recurse(accumulator,b,c,d,limit)
{
  if (limit == 0)
    printf("%i %i %i\n", b, c, d);
  else
    if (accumulator<limit)
    {
      recurse(accumulator+1,b,c,d,limit);
      recurse(0,accumulator,b,c,d);
    }
}

main()
{
  int x=2,y=3,z=4;
  recurse(0,0,x,y,z);
}

class tri_loop_tool
{
  private:
    size_t x, y, z;
    size_t i, j, k;

    void Over_z ();
    void Over_y ();
    void Over_x ();

  public:
    void operator() (size_t pi, pj, pk);
};

void tri_loop_tool::Over_z ()
{
  if (z < k)
  {
    cout << x << ", " << y << ", " << z << endl;
    z++;    Over_z ();
  }
}

void tri_loop_tool::Over_y ()
{
  if (y < j)
  {
    z = 0;  Over_z ();
    y++;    Over_y ();
  }
}

void tri_loop_tool::Over_x ()
{
  if (x < i)
  {
    y = 0;  Over_y ();
    x++;    Over_x ();
  }
}

void tri_loop_tool::operator() (size_t pi, pj, pk)
{
  i = pi; j = pj; k = pk;
  x = 0;  Over_x ();
}