i have an old codebase here, where they used protected member variables. Whether or not this is a good idea can be discussed. However, the code must have compiled fine with gcc3.
I have a derived template class Bar that uses protected member x from class template Foo like so
template <class Something> class Foo {
public:
// stuff...
protected:
some::type x;
}
template <class Something> Bar : Foo<Something> {
public:
void cleanup();
}
And in the method declaration of cleanup() there is something done with x
template <class Something> void Bar<Something>::cleanup() {
doSomeThingCleanUpLike (x);
}
This does not work with gcc4, although it should have worked with gcc3. It works when I change it to
doSomeThingCleanUpLike (this->x);
Why is that the case?
The expression x used in the derived class is, by the rules in the standard, not dependent on any template parameter of the derived class. Because of this, lookup happens in the context of the template definition and not at the point of use/instantiation. Even though the template base class of the template appears to be visible, because it is a template class the particular instantiation that might be used might involve specialized templates so the base class template definition cannot be used for name lookup.
By changing the expression to this->x you are making it a dependent expression (this in a class template always depends on the template parameters). This means that lookup will occur in the instantiation context at which point the base class is fully known and its members are visible.
When you're defining the derived template, the compiler only knows the base template class' name but not its details, so compiler doesn't know the derived class has an inherited member. In order to tell the compiler of the member's existence, use this->, just like you did.
Actually, it is a duplicate of this question.
