Let's say I have the following class hierarchy:
template< class T >
class TestBase {
public:
virtual T const & do_foo() = 0;
};
template< class T >
class TestDerived : public virtual TestBase< T > {
public:
virtual int do_bar() {
return do_foo() + 1;
}
};
GCC spits out the following:
error: there are no arguments to ‘do_foo’ that depend on a template parameter, so a declaration of ‘do_foo’ must be available [-fpermissive]
note: (if you use ‘-fpermissive’, G++ will accept your code, but allowing the use of an undeclared name is deprecated)
Now, if I change this to derive from a TestBase instantiated from a known type (e.g. class TestDerived : public virtual TestBase< int >
, this snippet compiles just fine so the problem apparently has to do with the base class type being unknown at compile time. But since I haven't instantiated objects of either class anywhere, I don't see why this should even matter.
Basically, how would I resolve the error without resorting to -fpermissive
?
Non-dependent names (that is, names which do not depend on template arguments), are looked up when parsing the template, not when instantiating it. You need to make do_foo
a dependent name. There are basically two ways to achieve this:
virtual int do_bar() {
return this->do_foo() + 1;
}
or
template< class T >
class TestDerived : public virtual TestBase< T > {
public:
using TestBase<T>::do_foo;
virtual int do_bar() {
return do_foo() + 1;
}
};
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With