Deriving from a templated base class

[m.tyka]

Hello,

I have the following code
---
template < typename T>
struct Base
{
T base_member;
};

template < typename T>
struct Child: public Base <T>
{
T myfunc(){ return base_member; }
};

int main(){
Child<intchild;
return 0;
}
---
To my surprise it does not appear to compile (using g++ 3.4):
temptest1.cpp: In member function `T Child<T>::myfunc()':
temptest1.cpp:10: error: `base_member' was not declared in this scope

However changing the myfunc() line to

T myfunc(){ return Base<T>::base_member; }

makes it work fine. Does anyone know why i have to explicitly define
the namespace ? I don't understand why it should be ambigous which
base_member i mean, since there's only one base class ? Is there a way
to make it work implicitly ?

Thanks for any help,

Mike

[Pete C]

http://www.parashift.com/c++-faq-lit...html#faq-35.19

[Salt_Peter]

m.****@gmx.net wrote:

Hello,

I have the following code
---
template < typename T>
struct Base
{
T base_member;
};

template < typename T>
struct Child: public Base <T>
{
T myfunc(){ return base_member; }
};

int main(){
Child<intchild;
return 0;
}
---
To my surprise it does not appear to compile (using g++ 3.4):
temptest1.cpp: In member function `T Child<T>::myfunc()':
temptest1.cpp:10: error: `base_member' was not declared in this scope

However changing the myfunc() line to

T myfunc(){ return Base<T>::base_member; }

makes it work fine. Does anyone know why i have to explicitly define
the namespace ? I don't understand why it should be ambigous which
base_member i mean, since there's only one base class ? Is there a way
to make it work implicitly ?

Thanks for any help,

Mike

As you've noticed, the compiler does not verify the base class for
non-dependant names.
If you plan to claim that base_member *is* dependant on T. Its not.
At least, not as far as the template name lookup is concerned.

To illustrate: If you add the following to the base class:

const T& get() const { return base_member; }
// or
T get() const { return base_member; }

those too need the qualifier, but...

const T& get(T t) const { return base_member; } // silly example, t is
ignored
// or
void set(const T& t) { base_member = t; }

these would *not* need the Base<T>:: qualifier since get(...) and
set(...) are dependants (their signatures are dependant on T).
IMHO, doesn't it make sense to qualify them anyways?