Is there a way to get around having to prefix template base class members with `this`?

Question

When inheriting from a template class, I need to prefix all base class members I access in the derived class with this:

template<typename T>
struct X{
   int foo;
   void bar();
};

template<typename T>
struct Y : public X<T> {

   void blub(){
       foo++; // Does not work
       this->foo++; // Fine
       bar(); // Does not work
       this->bar(); // Fine
   }
}

As I was hinted, the reason why you must prefix the members with this has already been answered HERE. So my remaining question is: Is there a way to avoid all the thises? For example, I have a method in the derived class that uses a lot of base class members. The code looks totally cluttered with all the this-> in it. Is there a way to omit these?

Answer 1

To make this work, you need to turn the non-dependent names foo and bar into dependent names. There are three ways to do this:

• Qualify them with this, as you have done. This has the downside that you need to do it everywhere you use the names. this is implicitly a dependent name.
• Qualify them with the base class name, as X<T>::foo and X<T>::bar. This also needs to be done everywhere you use them, and additionally breaks the virtual dispatch mechanism if they turn out to be virtual methods.
• Bring the dependent names into the non-dependent namespace by using X<T>::foo; and using X<T>::bar;.

Or, you can compile with VC++ which couldn't care less about the distinction between dependent and non-dependent names.