Bdtjtk

I'm trying to write a simple class for binary search tree that uses a class of nodes using templates. This is my code:

When I try to compile the code I get this error:
'Node<T>': no appropriate default constructor available'

for this line:
Tree() : root(0), counter(0) {}


and I don't understand why it would even use a default constructor here I'm just giving a value to a pointer of the class type.

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

} 

The message is a little misleading: it's not complaining about the members you've initialised, but the base that you didn't initialise. Therefore it's trying to use a default constructor of the base (Node<double>) that doesn't exist.

Perhaps you didn't mean to make Tree<T> derive from Node<T>?

Fixing that (and the shadowed T on that friend declaration), the code compiles.