Template lookup in class?

Question

It's hard to get a word for this. Sometimes I see a class like this:

template <typename T>
class Wrapper
{
public:
    Wrapper(const T& t) : t_(t) {}
    Wrapper(const Wrapper& w) : t_(w.t_) {}
private:
    T t_;
}

As far as I can tell this is legitimate code. However, why is the copy constructor allowed to accept a const Wrapper& without explicitly stating that it needs a const Wrapper<T>&. When else is the template type implied? Is it allowed to write the copy constructor this way if you don't use an in-class definition?

Answer 1

Basically, inside a class template definition you are allowed to use the template-name for the template being defined as a short hand for the full parameterized version of the template-id.

Answer 2

Within a templated class like this using the name of the class is the same as using Wrapper<T>.

Answer 3

It is explicitly specified by the language standard in 14.6.1/1:

Within the scope of class template, when the name of the template is neither qualified nor followed by <, it is equivalent to the name of the template followed by the template-parameters enclosed in <>.

This was re-worded (through the concept of "injected class name") in the later versions of the standard, but the point is that this behavior is explicitly spelled out in the document.

To answer the second part of your question, this rule also applies to parameter declarations when writing out-of-class method definitions, but it doesn't apply to the return type declarations. For example, this code is OK

template <typename T> struct S {
  S foo(S);
};

template <typename T> S<T> S<T>::foo(S s) {
  /* whatever */
}

but you can't remove the <T> bit from the return type in the definition of the method. (And you can't remove <T> from the qualified name of the method.)

As for the constructior specifically: your should use the full name (with <T>) for the class, but you should not use <T> in the name of the constructor itself. So the shortest form for out-of-class definition in your case would be

template <typename T> Wrapper<T>::Wrapper(const Wrapper& w) : t_(w.t_)
{
}

Note, that you can't add the <T> bit to the constructor name even if you want to

template <typename T> Wrapper<T>::Wrapper<T>(const Wrapper& w)
                                         ^ ERROR !!!

P.S. This last claim needs further research. Comeau Online compiler thinks it is an error, while GCC thinks it is OK. I'll return to it later.

P.P.S. The compiler in MSVC++ 2005 complains about the latter declaration with a warning

warning C4812: obsolete declaration style: please use 'Wrapper<T>::Wrapper' instead

Interesting...

Answer 4

No, out of class you have to write:

template <typename T>
Wrapper<T>::Wrapper<T>(const Wrapper<T>& w) : t(w.t) {}

But inside the class, Wrapper stands in for the "current class".

EDIT: This is for Andrew and his investigation into why a compiler would reject the on the constructor:

template <typename T>
class Foo {
public:
    Foo() {}
    Foo(const Foo& f);
};

template <typename T>
Foo<T>::Foo<T>(const Foo<T>& f) { }

int main(int argc, char** argv)
{
    Foo<int> f;
    Foo<int> g(f); // make sure the template is instantiated
}