views:

238

answers:

2

I have a base class, say BassClass, with some fields, which I made them protected, and some pure virtual functions. Then the derived class, say DerivedClass, like class DerivedClass : public BassClass. Shouldn't DerivedClass inherit the protected fields from BassClass? When I tried to compile the DerivedClass, the compiler complains that DerivedClass does NOT have any of those fields, what is wrong here? thanks

+2  A: 

If BassClass (sic) and DerivedClass are templates, and the BassClass member you want to access from DerivedClass isn't specified as a dependent name, it will not be visible.

E.g.

template <typename T> class BaseClass {
protected: 
    int value;
};

template <typename T> class DerivedClass : public BaseClass<T> {
public:
    int get_value() {return value;} // ERROR: value is not a dependent name
};

To gain access you need to give more information. For example, you might fully specify the member's name:

    int get_value() {return BaseClass<T>::value;}

Or you might make it explicit that you're referring to a class member:

    int get_value() {return this->value;}
Managu
The reason for this template behaviour, by the way, is that at the point where the DerivedClass template is defined, the compiler has no way of knowing whether `BaseClass<T>` is going to have a member `value` or not. You might late specialise `BaseClass<int>` so that it doesn't have one, and then try to instantiate `DerivedClass<int>`. So the template definition is supposed to be rejected. By adding the extra information you're saying "it's OK, what `value` is depends on `T`, so don't expect to be able to find it yet".
Steve Jessop
Alternatively, we can do `using BaseClass<T>::value;` in the derived class declaration, which would allow the rest of the derived class to simply call `value`.
int3
A: 

This works:

#include <iostream>

struct Base {
virtual void print () const = 0;
protected:
int val;
};

struct Derived : Base {
void print () { std::cout << "Bases's val: " << val << std::endl; }
};
rmn