consider the code below:
template
class C {
struct P {};
vector vec;
void f();
};
template void C::f() {
typename vector::iterator p = vec.begin();
}
Why is the "typename" keyword necessary in this example?
Are there any other cases where "typename" must be specified?
Answer
Short answer: Whenever referring to a nested name that is a dependent name, i.e. nested inside a template instance with unknown parameter.
Long answer: There are three tiers of entities in C++: values, types, and templates. All of those can have names, and the name alone doesn't tell you which tier of entity it is. Rather, the information about the nature of a name's entity must be inferred from the context.
Whenever this inference is impossible, you have to specify it:
template struct Magic; // defined somewhere else
template struct A
{
static const int value = Magic::gnarl; // assumed "value"
typedef typename Magic::brugh my_type; // decreed "type"
// ^^^^^^^^
void foo() {
Magic::template kwpq(1, 'a', .5); // decreed "template"
// ^^^^^^^^
}
};
Here the names Magic
, Magic
and Magic
had to be expliciated, because it is impossible to tell: Since Magic
is a template, the very nature of the type Magic
depends on T
-- there may be specializations which are entirely different from the primary template, for example.
What makes Magic
a dependent name is the fact that we're inside a template definition, where T
is unknown. Had we used Magic
, this would be different, since the compiler knows (you promise!) the full definition of Magic
.
(If you want to test this yourself, here's a sample definition of Magic
that you can use. Pardon the use of constexpr
in the specializaation for brevity; if you have an old compiler, feel free to change the static member constant declaration to the old-style pre-C++11 form.)
template struct Magic
{
static const T gnarl;
typedef T & brugh;
template static void kwpq(int, char, double) { T x; }
};
template <> struct Magic
{
// note that `gnarl` is absent
static constexpr long double brugh = 0.25; // `brugh` is now a value
template static int kwpq(int a, int b) { return a + b; }
};
Usage:
int main()
{
A a;
a.foo();
return Magic::kwpq(2, 3); // no disambiguation here!
}
No comments:
Post a Comment