C++: Scope of templated base class? - c++

Question

This code does not compile:
template <typename T>
struct B {
typedef T type;
};
struct D0 : public B<int> {
void h(type) { }
};
template <typename T>
struct D : public B<T> {
void f(typename B<T>::type) { }
void g(type) { }
};
http://ideone.com/pVh94t
Specifically, although D0::h(type) and D::f(typename B<T>::type) compile, D::g(type) does not. Why is type not visible in D?

Answer 1

Answer can be found in two places. First C++11 draft standard N3337:
§14.6.2/3
In the definition of a class template or a member of a class template,
if a base class of the class template depends on a template-parameter,
the base class scope is not examined during unqualified name lookup
either at the point of definition of the class template or member or
during an instantiation of the class template or member. [ Example:
typedef double A;
template<class T> class B {
typedef int A;
};
template<class T> struct X : B<T> {
A a; // a has type double
};
The type name A in the definition of X<T> binds to the typedef
name defined in the global namespace scope, not to the typedef name
defined in the base class B<T>. — end example ]
(Bold emphasis mine)
Second, the parashift FAQ provides a human-readable explanation in Why am I getting errors when my template-derived-class uses a nested type it inherits from its template-base-class?:
Perhaps surprisingly, the following code is not valid C++, even though
some compilers accept it:
template<typename T>
class B {
public:
class Xyz { /*...*/ }; // Type nested in class B<T>
typedef int Pqr; // Type nested in class B<T>
};
template<typename T>
class D : public B<T> {
public:
void g()
{
Xyz x; // Bad (even though some compilers erroneously (temporarily?) accept it)
Pqr y; // Bad (even though some compilers erroneously (temporarily?) accept it)
}
};
This might hurt your head; better if you sit down.
Within D<T>::g(), name Xyz and Pqr do not depend on template parameter
T, so they are known as a nondependent names. On the other hand, B<T>
is dependent on template parameter T so B<T> is called a dependent
name.
Here’s the rule: the compiler does not look in dependent base classes
(like B<T>) when looking up nondependent names (like Xyz or Pqr). As a
result, the compiler does not know they even exist let alone are
types.
At this point, programmers sometimes prefix them with B<T>::, such as:
template<typename T>
class D : public B<T> {
public:
void g()
{
B<T>::Xyz x; // Bad (even though some compilers erroneously (temporarily?) accept it)
B<T>::Pqr y; // Bad (even though some compilers erroneously (temporarily?) accept it)
}
};
Unfortunately this doesn’t work either because those names (are you
ready? are you sitting down?) are not necessarily types. “Huh?!?” you
say. “Not types?!?” you exclaim. “That’s crazy; any fool can SEE they
are types; just look!!!” you protest. Sorry, the fact is that they
might not be types. The reason is that there can be a specialization
of B<T>, say B<Foo>, where B<Foo>::Xyz is a data member, for example.
Because of this potential specialization, the compiler cannot assume
that B<T>::Xyz is a type until it knows T. The solution is to give the
compiler a hint via the typename keyword:
template<typename T>
class D : public B<T> {
public:
void g()
{
typename B<T>::Xyz x; // Good
typename B<T>::Pqr y; // Good
}
};

Answer 2

Apparently, this is due to the compiler's order of semantic compilation phases. It happens that, to the compiler's view, the symbol type is not present in any scope, because it hasn't (yet) instantiated templates, and thus, it hasn't instantiated D itself.
The only workaround is to force the compiler to resolve the symbol in a later phase of semantic compilation, such as with...
void f(typename B<T>::type) {}
Or, if the derived class is not a template, but the base class is, the compiler is forced to resolve/instantiate/whatever the base class first, thus avoiding any possible errors inside the derived class.
But this is not the case if both base and derived are templates, because the compiler will look-up a symbol for the derived in all already instantiated scopes (such as the global scope) before instantiating the derived template class, and if it fails, well you already know what happens with int main(){printf("%d\n", argc);}, no?