Why inner "template" class not allowed inside function? [duplicate]

Question

Reading C++ Templates: The Complete Guide and it says

Note that templates cannot be declared in a function

It does not give explanation and/or cross reference to any other chapter in the book or external resource.

Could someone help in explaining this. Probably it is explained later in the book but not there yet. If explained earlier, I must have missed it.

Example:

int main()
{
  class DummyClass  //  This compiles ok
  {
    int object;
  };

  template <typename T> //  compile error "expected primary-expression before "template""
  class DummyTemplate
  {
    T object;
  };

  return 0;
}

I do not understand the error message from gcc either. The error message says:

expected primary-expression before "template"

Answer 1

The problem is probably linked to the historical way templates were implemented: early implementation techniques (and some still used today) require all symbols in a template to have external linkage. (Instantiation is done by generating the equivalent code in a separate file.) And names defined inside a function never have linkage, and cannot be referred to outside of the scope in which they were defined.

Answer 2

The answer "because standard says so", is of course correct, but let's consider generic lambdas.

In C++14 and C++17 generic lambdas are the only way of writing template-like code that I know of:

    auto lambda = [](auto x) { };
    lambda.operator()<int>(0);

Technically, you can write any kind of template code just with that. Though you'll have to work hard to work around various limitations of this approach.

That will be simpler in C++20 though. With template parameter list in generic lambdas you will be able to write code like this:

    auto size = []<class T>() { return sizeof(T); };
    static_assert(4 == size.operator()<int>());

GCC already supports this syntax.

Answer 3

The short answer to why this is, is because that how the guys who wrote the c/c++ compilers and standards wanted it to be. Templates inside functions must have been deemed too chaotic and/or difficult to understand or parse, so they forbade it.

Answer 4

My guess is that it is hard to implement, that's why it is not allowed (in Standard C++03). Writing class templates outside of functions is an acceptable solution from the other hand.