Question

What is the difference between

template <class T>
class why
{
public:
   why()
   {}
};

and

template <class T>
class why
{
public:
   why<T>()
   {}
};

They both seem to work the same and compile.

EDIT

And, if they are truly the same, why is this functionality even in the C++ language?

Answer 1

They’re equivalent. In the former, why is an injected name that’s defined to be the same as why<T> (where T is the actual template argument.) This exists for ease of typing.

---

Note that this injection is into the class’s scope, and not outside of it. Obvious, but given:

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

A common mistake might be to try and define x like this:

template <typename T>
foo foo<T>::x(foo f) { return f; }

But this would be an error, as foo in the return type needs template arguments. The foo in the parameter list is okay, though, because after foo<T>:: we’re in the class’s scope, and foo is defined to be foo<T>. So the correct way to do this is either of these:

template <typename T>
foo<T> foo<T>::x(foo f) { return f; }

template <typename T>
foo<T> foo<T>::x(foo<T> f) { return f; } // equivalent