c++ - 如何在 C++ 类中使用模板化结构

Question

我正在尝试在类中使用模板化的struct，但不知道如何正确地声明它

template<typename var>
struct Node
{
    var value;
    Node* left;
    Node* right;
};

class Tree
{
public:
    Tree();
    ~Tree();
    template<typename var>
    void insert(var key, Node *node);
    template<typename var>
    Node* search(var key, Node *node);
    void deleteTree(Node *node);
    void inOrderTraversePrint(Node* node);
    void preOrderTraversePrint(Node* node);
    void postOrderTraversePrint(Node* node);
    Node* getRoot();
    void resetRoot();
private:

    Node* root;
};

我不断收到“Node is not a type”和“Invalid use of template-name Node without an argument list”错误。

我知道如何模板化单个 class 和类内外的方法，但这是我第一次使用 struct 并尝试使用模板化的 struct 在一个类中。在类中声明和使用 templated struct 的正确方法是什么。

Answer 1

如果 Node 在内部使用 var 类型，那么它也应该由它模板化:

template<typename var>
struct Node
{
    var value;
    Node* left;
    Node* right;
};

template<typename T>
class Tree
{
public:
    Tree();
    ~Tree();

    void insert(T key, Node<T> *node);
    Node<T>* search(T key, Node<T> *node);
    void deleteTree(Node<T> *node);
    void inOrderTraversePrint(Node<T>* node);
    void preOrderTraversePrint(Node<T>* node);
    void postOrderTraversePrint(Node<T>* node);
    Node<T>* getRoot();
    void resetRoot();
private:

    Node<T>* root;
};

编辑:

this is first time I am using struct and trying to use templated struct within a class. What is proper way to declare and use templated struct within a class.

如果您的树数据始终具有相同的类型，您可以不用模板化 Tree 类:

class Tree
{
public:
    Tree();
    ~Tree();
    void insert(var key, Node<int> *node);
    Node* search(var key, Node<int> *node);
    void deleteTree(Node<int> *node);
    void inOrderTraversePrint(Node<int>* node);
    void preOrderTraversePrint(Node<int>* node);
    void postOrderTraversePrint(Node<int>* node);
    Node<int>* getRoot();
    void resetRoot();
private:

    Node<int>* root;
};

第二次编辑

节点的变体实现:

class Node
{
    virtual std::string ToString() = 0; // convert value to string
    virtual ~Node() = default;
    Node *left, *right;
};

template<typename T>
class ValueNode: public Node
{
    T value_;
public:
    ValueNode(T value): Node{ nullptr, nullptr }, value_{ std::move(value) } {}

    std::string ToString() override;
    {
        std::ostringstream oss;
        oss << value_;
        return oss.str();
    }

    virtual ~ValueNode() = default;
};

class Tree
{
public:
    Tree();
    ~Tree();
    template<typename var>
    void insert(var key, Node *node)
    {
        // insert new ValueNode<var>{ key } here
    }

    template<typename var>
    Node* search(var key, Node *node);
    void deleteTree(Node *node);
    void inOrderTraversePrint(Node* node);
    void preOrderTraversePrint(Node* node);
    void postOrderTraversePrint(Node* node);
    Node* getRoot();
    void resetRoot();
private:

    Node* root;
};

这里的想法是以相同的方式识别所有应用于所有节点值的操作(在我的示例代码中，这意味着“将值转换为字符串”)并(首先)将它们声明为 Node，然后根据值类型实现它们(作为 ValueNode 中的虚函数实现)。

这将允许您抽象化您在 Tree 类中的节点中有多种类型的事实。

也就是说，如果您使用 boost，您可能应该在原始代码中使用 boost::variant 或 boost::any 代替 Node 中的 typename var .