没有作为模板对象本身的类成员的默认构造函数

Question

我正在尝试为二进制搜索树编写一个简单的类，该类使用使用模板的节点类。 这是我的代码：

当我尝试编译代码时，出现此错误：
'Node<T>': no appropriate default constructor available'
对于这一行：
Tree() : root(0), counter(0) {}

而且我不明白为什么它甚至会在这里使用默认构造函数，我只是给类类型的指针赋一个值。

#include <iostream>
#include <string>

using namespace std;

template <typename T>
class Node {
public:
    Node(const T &value) : value(value), Left(0), Right(0) {}

    ~Node() {
        if (Left != 0)
            delete Left;
        if (Right != 0)
            delete Right;
    }

    Node& getLeft() { return *Left; }

    Node& getRight() { return *Right; }

private:
    Node* Left;
    Node* Right;
    T value;
};


template <typename T>
class Tree : public Node<T> {
public:
    template<typename T>
    friend ostream& operator<<(ostream& output, const Tree<T> &t);

    Tree() : root(0), counter(0) {}

    Tree(const T &rootValue) : root(new Node<T>(rootValue)), counter(1) {}

    ~Tree() { delete root; }

    Tree& insert(const T &value) {
        Node<T> *runner = root;
        Node<T> *replacer = root;
        if (runner == 0)
            root = new Node<T>(value);
        else
        {
            while (runner != 0)
            {
                replacer = runner;
                if (value > runner->value)
                    runner = runner->Right;
                else
                    runner = runner->Left;
            }
            if (value > replacer->value)
                replacer->Right = new Node<T>(value);
            else
                replacer->Left = new Node<T>(value);
        }
        counter++;
        return *this;
    }

    bool exists(const T &value) const {
        Node<T> *runner = root;
        while (runner != 0)
        {
            if (value == runner->value)
                return true;
            if (value > runner->value)
                runner = runner->Right;
            else
                runner = runner->Left;
        }
        return false;
    }

    int size() const { return size; }

private:
    Node<T> *root;
    int counter;
};

template<typename T>
string preorderToString(const Node<T> &n) {  //Function that receives a tree and returns a string of the preorder traversal of it
    string left, middle, right;
    if (n.Left != 0)
        left = preorderToString((*n.Left)) + " ";
    middle = to_string(n.value);
    if (n.Right != 0)
        right = " " + preorderToString((*n.Right));
    return  left + middle + right;
}

template<typename T>
ostream& operator<<(ostream& output, const Tree<T> &t) //Operator overloading that uses the function 'preorderToString' to print the tree contents
{
    return output << preorderToString<T>(*(t.root));
}


int main() {
    Tree<double> test;
} 

Answer 1

该消息有点误导性：它不是在抱怨您已初始化的成员，而是您没有初始化的基础。 因此，它正在尝试使用不存在的基类的默认构造函数（ Node<double> ）。

也许您不是要让Tree<T>从Node<T>派生？

修复该问题（以及该朋友声明上的阴影T ）， 代码将进行编译 。