复制构造函数中的模板

Question

Could you please tell me why I am getting the compilation error

template<class T> class 'Node' used without template parameters

with the following code

template<class T>
    class Node
    {
        private:
            T _value;
            vector<Node*> children;

        public:
            Node(T value);
            Node<T>(const Node<T>& node);
            void AddChild(Node<T>* node);
            T getValue();
            vector<Node<T>*> returnChildren();
            ~Node();
    };

    template <class T>
    Node::Node<T>(T value):_value(value)
    {
    }

Answer 1

template <class T>
Node<T>::Node(T value):_value(value)
{
}

Try this one.

Answer 2

When you wrote

Node::Node<T>(T value):_value(value)

You have no template parameter on the class (the first Node on that line) but instead have one on the constructor (the second Node ). That is incorrect.

Answer 3

In your case, Node is the template class. When you use that class, you have to use it with template parameters. This does not work :

template <class T>
Node::Node(T value):_value(value)
{
}

Because the class Node is templated and you use it without template parameter.

This does not work neither because you put the template parameters on the function (here the constructor) not the class.

template <class T>
Node::Node<T>(T value):_value(value)
{
}

This does work.

template <class T>
Node<T>::Node(T value):_value(value)
{
}

You use this syntax only for the class, it differs when you write a function.

For function.
Let's say we have this class

class MyTemplate
{
    template<typename T>
    void foo(T val);
};

You may define the method like that :

template<typename T>
void MyTemplate::foo<T>(T val)
{

};

But it fails. Clang prints this error :

function template partial specialization is not allowed

For function you don't need it, you have to write

template<typename T>
void MyTemplate::foo(T val)
{
}

And if you want to specialize it, you can write

template<>
void MyTemplate::foo(int val)
{
}

Or

template<>
void MyTemplate::foo<int>(int val)
{
}

Declaration :

When you declare a variable of type Node, you have to use the template parameter too.

Node<int> myNode(12);