accessing protected members of superclass in C++ with templates
c++, inheritance, templates
Solution
This can be amended by pulling the names into the current scope using `using`:
template<typename T> struct Subclass : public Superclass<T> {
using Superclass<T>::b;
using Superclass<T>::g;
void f() {
g();
b = 3;
}
};
Or by qualifying the name via the `this` pointer access:
template<typename T> struct Subclass : public Superclass<T> {
void f() {
this->g();
this->b = 3;
}
};
Or, as you’ve already noticed, by qualifying the full name.
The reason why this is necessary is that C++ doesn’t consider superclass templates for name resolution (because then they are dependent names and dependent names are not considered). It works when you use `Superclass<int>` because that’s not a template (it’s an instantiation of a template) and thus its nested names are not dependent names.
Problem
Why can't a C++ compiler recognize that `g()` and `b` are inherited members of `Superclass` as seen in this code: ``` template<typename T> struct Superclass { protected: int b; void g() {} }; template<typename T> struct Subclass : public Superclass<T> { void f() { g(); // compiler error: uncategorized b = 3; // compiler error: unrecognized } }; ``` If I simplify `Subclass` and just inherit from `Subclass<int>` then it compiles. It also compiles when fully qualifying `g()` as `Superclass<T>::g()` and `Superclass<T>::b`. I'm using LLVM GCC 4.2. Note: If I make `g()` and `b` public in the superclass it still fails with same error.