再一次，感觉模板：

Question

我遇到以下情况：

template<size_t Level>
class Node
{
public:

    Node()
    {
        for (size_t i = 0; i < children.size(); i++)
            children[i].reset(new Node<Level - 1>());
    }

    array<unique_ptr<Node<Level - 1>>, 4> children;
};


template<>
class Node<0>
{
};

...

Node<2> root;

我需要创建一个节点树，其中每个节点，但最后一个（level = 0），有4个子节点。我想将孩子存放在std:array的{{1}}。

我的解决方案是正确的还是我做错了，并且有更聪明的方法来实现这一结果？

Answer 1

我没有看到这里有模板的价值。树是固定的，有限的大小，你可以使它成为一个值类型。

E.g。一个4级树，其叶节点包含V类型的值：

namespace Tree {

    template <typename V>
    struct Root {

        struct Tier1 {
            struct Tier2 {
            struct Tier3 {
            struct Leaf { V value; };

            std::array<Leaf, 4> children;
            };
            std::array<Tier3, 4> children;
            };
            std::array<Tier2, 4> children;
        };

        std::array<Tier1, 4> children;
    };
}

当然，如果节点在所有级别都是可选的，请使用boost::optional<>：

std::array<optional<Leaf>, 4> children; };
std::array<optional<Tier3>, 4> children; };
std::array<optional<Tier2>, 4> children; };
std::array<optional<Tier1>, 4> children;

如果你没有提升，你可以使用unique_ptr作为穷人的可选项（但这会对内存布局产生很大影响）。

再一次，感觉模板：

您可以使用模板表达相同内容：

<强> Live On Coliru

#include <array>
#include <boost/optional.hpp>

namespace Tree {

    using boost::optional;

    template <typename LeafValue, int level> struct Node;

    template <typename LeafValue> struct Node<LeafValue, 3> {
        LeafValue value;
    };

    template <typename LeafValue, int level> struct Node {
        std::array<optional<Node<LeafValue, level+1> >, 4> children;
    };

    template <typename LeafValue> using Root = Node<LeafValue, 0>;
}


int main() 
{
    Tree::Root<int> a = {
    };
}

子模板类的树是std :: std :: unique_ptr的数组

1 个答案:

再一次，感觉模板：