C++ 定义递归构造函数的标准方法是什么？

C++ What's the standard way to define a recursive constructor?

本文关键字：方法 是什么 标准 定义 递归 构造函数 C++      更新时间：2023-10-16

对不起，我现在编辑了我的问题。注意粗体字。

在定义kdtree类时，我确实需要一个递归构造函数。但恐怕我做这件事的方式不对。我怎样才能做得更优雅？

这是我使用This指针的代码，它编译并运行良好。什么都不要做，只是展示递归构造函数应该是什么样子的简要想法。

#include <iostream>
using namespace std;
class foo
{
public:
  int a, b;
  foo(unsigned int k)//this piece of code just shows the brief idea of what i'm trying to do.
  {
    if (k)
      *this = foo(--k);
    else
      a = k, b = k;
  }
};
int main()
{
  foo f(3);
  cout << f.a << f.b << endl;
  getchar();
}

这是我的kdtree示例代码这就是我实际想要实现的，但不编译。我稍后会编辑它。

class kdtree
{
public:
  int16_t count;//数组里面可以只存mask和key生成的unique_key，因为树结构，和count可以后期生成
  int16_t key;
  int16_t mask;
  inline bool is_full()
  {
    return mask + count == 0x8000;
  };
  shared_ptr<kdtree> left, right;
  kdtree(){}
  kdtree(int x1, int y1, int z1, int x2, int y2, int z2, int _x = 0, int _y = 0, int _z = 0, int len = 0, int ikey = 0x8000)
  {
    int i = 0x80 >> len / 3, j = 0x4000 >> len;
    if ((x2 - x1)*(y2 - y1)*(z2 - z1) == j << 10)
    {
      count = j << 1;
      key = ikey;
      mask = ~ikey ^ (ikey - 1);
      return;
    }
    switch (len++ % 3)
    {
    case 0:
      if (x1 < _x&&x2 < _x)
      {
        *this = kdtree(x1, y1, z1, x2, y2, z2, _x, _y, _z, len, ikey -= j);
        return;
      }
      if (x1 >= _x&&x2 >= _x)
      {
        *this = kdtree(x1, y1, z1, x2, y2, z2, _x + i, _y, _z, len, ikey += j);
        return;
      }
      left = shared_ptr<kdtree>(new kdtree(x1, y1, z1, _x, y2, z2, _x, _y, _z, len, ikey -= j));
      right = shared_ptr<kdtree>(new kdtree(_x, y1, z1, x2, y2, z2, _x + i, _y, _z, len, key += j));
      count = j << 1;
      key = ikey;
      mask = ~ikey ^ (ikey - 1);
      return;
    case 1:
      if (y1 < _y&&y2 < _y)
      {
        *this = kdtree(x1, y1, z1, x2, y2, z2, _x, _y, _z, len, ikey -= j);
        return;
      }
      if (y1 >= _y&&y2 >= _y)
      {
        *this = kdtree(x1, y1, z1, x2, y2, z2, _x, _y + i, _z, len, ikey += j);
        return;
      }
      left = shared_ptr<kdtree>(new kdtree(x1, y1, z1, x2, y2, z2, _x, _y, _z, len, ikey -= j));
      right = shared_ptr<kdtree>(new kdtree(x1, y1, z1, x2, y2, z2, _x, _y + i, _z, len, ikey += j));
      count = j << 1;
      key = ikey;
      mask = ~ikey ^ (ikey - 1);
      return;
    case 2:
      if (x1 < _x&&x2 < _x)
      {
        *this = kdtree(x1, y1, z1, x2, y2, z2, _x, _y, _z, len, ikey);
        return;
      }
      if (x1 >= _x&&x2 >= _x)
      {
        *this = kdtree(x1, y1, z1, x2, y2, z2, _x, _y, _z + i, len, ikey + j);
      }
      left = shared_ptr<kdtree>(new kdtree(x1, y1, z1, x2, y2, _z, _x, _y, _z, len, ikey));
      right = shared_ptr<kdtree>(new kdtree(x1, y1, _z, x2, y2, z2, _x, _y, _z + i, len, ikey + j));
      count = j << 1;
      key = ikey;
      mask = ~ikey ^ (ikey - 1);
      return;
    }
  }
};

构造函数只构建一个东西，所以不能使用构造函数来构建一组东西。

如果使用新类[20]；//分配了20个类，但每个类在构造函数中构造一次。

class Class
{
    Class * left;
    Class * right;
    Class(  SomeObject & x )
    {
         eatSomeData( x );
         left = nullptr;
         right = nullptr;
         if (x->buildleft() )
             left = new Class( x );
         if (x->buildright() )
             right = new Class( x );
    }
};

在每次调用构造函数时，构造函数只处理它正在创建的对象，事实上它是递归地（基于x中的数据）这样做的，这有点不同。在这种情况下，类被大量绑定到树中，如果不构建树，就无法轻松构建。是的，这是可能的（从评论来看），但确实不可取。

如果你有一组想要存储的项目（例如一棵树），典型的构建块是

  1. Item—存储在树中的事物（对象）
  2. Node-一个了解树以及如何遍历树的对象
  3. TreeContainer-一个位于树顶部的对象，它知道如何查找存储的Item
  4. Builder-一个对象或函数，通过调用TreeContainer的方法获取数据并将其添加到树中
相关文章：