Why can't templates be declared in a function?

开发者_StackOverflow中文版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"

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.

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.

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.

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.

It means you cannot do something like the following

  void foo()
  {
       template <typename T> //Error
       T something;
  }

Template declarations are only permitted at global, namespace, or class scope. :)

What is the reasoning behind it?

It is not allowed because the Standard says so .

ISO C++-98 (Section 14.2)

A template declaration can appear only as a namespace or class scope declaration.

Does that make sense?

What exactly would be the use? So you can declare template variables that you can only use within the function? Is that really useful?

The only time this would be useful would be if you created multiple instances of the template with different types withing the one function. Move your private classes out of your functions anyway. If that starts to clutter up your classes then they are too big and need to be refactored.