我能否在编译时使用模板健壮地构建具有多个已知类型和已知最大深度的树?

我想我知道你想要什么，以及你如何才能实现它。但是，我认为它不太适合SO格式。

首先，创建&使用树:

int main()
{
    // We want a tree with 4 levels.
    // The node type of the 0th level should be `int`,
    // of the 1st level `double` and so on.
    // (0th level = tree root)
    // And we initialize the root node with the `int` 42.
    auto my_tree = make_tree_root < int, double, char, float, int > (42);
    // add children and navigate through the tree
    my_tree.add_child(1.23);
    my_tree.add_child(4.56);
    my_tree.get_child(1).add_child('x');
    my_tree.get_child(1).get_child(0).add_child(1.2f);
    my_tree.print();
}

现在是混乱的背景。请注意，这是一个概念验证，它有很多缺陷，没有注释可能是一种祝福。特别是用于减少代码复制的多重继承产生的问题比解决的问题要多。

#include <cstddef>
#include <iostream>    
#include <vector>
template < typename... TP >
struct type_vector
{
private:
    template < std::size_t t_count, typename TT, typename... TTP >
    struct access_elem { using value = typename access_elem < t_count-1, TTP... > :: value; }; 
        template < typename TT, typename... TTP >
        struct access_elem < 0, TT, TTP... > { using value = TT; };
public:
    template < std::size_t t_id >
    using elem = typename access_elem < t_id, TP... > :: value;
};

template < typename, std::size_t, std::size_t >
struct tree_node;
template < typename T_type_vector, std::size_t t_level, std::size_t t_maxLevel >
struct tree_all_base
{
    using node = typename T_type_vector::template elem < t_level >;
protected:
    node m_node;
public:
    explicit tree_all_base(node p) : m_node(p) {}
    void change_node(node);
    node get_node() const { return m_node; }
    void print() const
    {
        std::cout << "node: " << m_node << std::endl;
    }
};
template < typename T_type_vector, std::size_t t_level, std::size_t t_maxLevel >
struct tree_down_base
{
    using child = tree_node < T_type_vector, t_level+1, t_maxLevel >;
private:
    std::vector<child> m_children;
public:
    void add_child(typename child::node p)
    {
        using derived_type = tree_node < T_type_vector, t_level, t_maxLevel >;
        m_children.push_back( child{p, static_cast<derived_type*>(this)} );
    } 
    child const& get_child(std::size_t id) const { return m_children.at(id); }
    child& get_child(std::size_t id) { return m_children.at(id); }
    // further methods like `remove_child` etc
protected:
    void print() const
    {
        std::cout << "children: ";
        for(child const& c : m_children)
        {
            std::cout << c.get_node() << ", ";
        }
        std::cout << std::endl;
        for(child const& c : m_children)
        {
            c.print();
        }
        std::cout << std::endl;
    }
};
template < typename T_type_vector, std::size_t t_level, std::size_t t_maxLevel >
struct tree_up_base
    : public tree_all_base < T_type_vector, t_level, t_maxLevel >
{
    using tree_all_base_ = tree_all_base<T_type_vector,t_level,t_maxLevel>;
    using parent = tree_node < T_type_vector, t_level-1, t_maxLevel >;
    using node = typename tree_all_base_::node;
protected:
    parent* m_parent;
    tree_up_base(node p_node, parent* p)
        : tree_all_base_(p_node), m_parent(p)
    {}
};

template < typename T_type_vector, std::size_t t_level, std::size_t t_maxLevel >
struct tree_node
    : public tree_up_base  <T_type_vector, t_level, t_maxLevel>
    , public tree_down_base<T_type_vector, t_level, t_maxLevel>
{
    using node = typename tree_all_base<T_type_vector,t_level,t_maxLevel>::node;
private:
    /* inherit ctor....*/
    using tree_up_base_ = tree_up_base<T_type_vector,t_level,t_maxLevel>;
    using tree_down_base_ = tree_down_base<T_type_vector,t_level,t_maxLevel>;
    using tree_node_parent = tree_node<T_type_vector,t_level-1,t_maxLevel>;
    friend struct tree_down_base < T_type_vector, t_level-1, t_maxLevel >;
    tree_node(node p, tree_node_parent* pb) : tree_up_base_(p, pb) {}
public:
    void print() const
    {
        tree_up_base_::print();
        tree_down_base_::print();
    }
};
    // tree root specialization
    template < typename T_type_vector, std::size_t t_maxLevel >
    struct tree_node < T_type_vector, 0, t_maxLevel >
        : public tree_all_base <T_type_vector, 0, t_maxLevel>
        , public tree_down_base<T_type_vector, 0, t_maxLevel>
    {
    public:
        /* inherit ctor..... */
        using tree_all_base_ = tree_all_base<T_type_vector,0,t_maxLevel>;
        using tree_down_base_ = tree_down_base<T_type_vector,0,t_maxLevel>;
        using node = typename tree_all_base_ :: node;
        tree_node(node p) : tree_all_base_(p) {}
    public:
        void print() const
        {
            tree_all_base_::print();
            tree_down_base_::print();
        }
    };
    // tree leaf specialization
    template < typename T_type_vector, std::size_t t_maxLevel >
    struct tree_node < T_type_vector, t_maxLevel, t_maxLevel >
        : public tree_up_base <T_type_vector, t_maxLevel, t_maxLevel>
    {
    private:
        /* inherit ctor.... */
        using tree_up_base_ = tree_up_base<T_type_vector,t_maxLevel,t_maxLevel>;
        using node = typename tree_up_base_ :: node;
        using tree_node_parent = tree_node<T_type_vector,t_maxLevel-1,t_maxLevel>;
        friend struct tree_down_base < T_type_vector, t_maxLevel-1, t_maxLevel >;
        tree_node(node p, tree_node_parent* pb) : tree_up_base_(p, pb) {}
    };
template < typename... TP >
tree_node < type_vector<TP...>, 0, sizeof...(TP)-1 >
make_tree_root(typename type_vector<TP...>::template elem<0> node)
{ return {node}; }