c++ - When should I use the keyword "typename" when using templates

Question

I've been working lately on a small project, and I couldn't figure out something..

I've been given a .h file that was containing a class, using a typename template. Inside that class there was a private class.

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

        Node* Function1(int index);
        int Index(const T& id);


private:
        class Node()
        {
                public:
                T id;

                //Imagine the rest for the Node


        };      
};

The problem occured when I wanted to define the functions of the class "Something"

Here's how I was doing it (in a .inl file)

template<typename T>
Node* Something::Function1(int index) //Is the return type well written?
{
        // returns the node at the specified index
}

template<typename T>
int Something::Index(const T& id) //Is the parameter type well specified?
{
        // returns the index of the node with the specified id
}

So the bugging part was in the definitions part... Do I have to tell the compiler that the return type (in this case Node*) uses the typename template (like this: typename Node*) ? And what about the parameter ? typename const Node& ?

So basically, when do I have to specify wether the function/parameter uses a template?

Thanks for your time.

Answer 1

For Function1, you need to tell the compiler what Node is -- in this case, it's a nested type inside Something<T>. Because it's dependent on T (it's a dependent name), you need to tell the compiler it's a type, so you must write it as typename Something<T>::Node. The issue is that there might be some T for which Something<T>::Node isn't actually a type (i.e. if you partially specialize Something<T>).

For Index, what you have is fine -- const T& is just a reference to a const T, and the compiler knows what T is.