Why can't templates be declared in a function?

Question

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

Note that templates cannot be declared in a function

It does not give e

Answer 1

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 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

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

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.

Answer 5

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?

Answer 6

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.