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

Question

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

我确实需要一个递归构造函数，同时定义一个kdtree类。但我恐怕我没有按照正确的方式去做。 我该如何更优雅地做到这一点？

这是我的代码，使用这个指针，它编译，并运行良好。 不要做任何事情，只是显示递归构造函数应该看起来像的简短概念。

#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; 
    } 
    } 
}; 

Answer 1

构造函数只构建一件事物，所以你不能使用构造函数来构建一组事物。

如果您使用新的Class [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
的调用方法将其添加到树