Dear all,
C++98 14.3.1 explicitly says as follows:
"A local type, a type with no linkage, an unnamed type or a type
compunded from any of these types shall not be used as a template-
argument for a template type-parameter."
And the Standard also immediately gives an example:
/*-- Source Code Begin --*/
template<class T> class X {};
void f()
{
struct S {};
X<S> x3; // error: local type used as template-argument
}
/*-- Source Code End --*/
Nevertheless, the source code should can be correctly compiled by
Visual C++. Moreover, C++0x 14.4.1 explicitly says differently as
follows:
"A template-argument for a template-parameter which is a type
shall be a type-id."
C++0x 14.4.1 also immediately gives some examples as follows:
/*-- Source Code Begin --*/
template<class T> class X {};
template<class T> void f(T t) {}
struct {} unnamed_obj;
void f()
{
struct A {};
enum { e1 };
typedef struct { } B;
B b;
X<A> x1; // OK
X<A*> x2; // OK
X<B> x3; // OK
f(e1); // OK
f(unnamed_obj); // OK
f(b); // OK
}
/*-- Source Code End --*/
Obviously, both of the most popular C++ compiler and C++0x relax
the restrictions put by C++98.
In my view, the new rules without restrictions are intuitive, easy
to use for programmers and easy to implement for compilers. What
makes me most puzzled is the hidden reason for the authors of
C++98 to put such counterintuitive restrictions on compilers and
on us innocent programmers? What's the WHY behind the C++98
restrictions?
figure out what it should mean. If you have two struct S in two