Why do I have to access template base class members through the ‘this’ pointer?

Ever tried calling a base class function in a C++ template and triggering a confusing compiler error? That’s not a bug, it’s just C++ looking up names in templates! Why doesn’t the compiler find the base class member, though, and how does this-> make it work? In this article, we will discuss the dependent names in template inheritance, show you why the compiler loses, and dive into best practices of using base class members in templates.

Table of contents

• Importance of Template-Based Inheritance
• Understanding the Problem with Dependent Names in Template Inheritance
  • The Problem in Accessing Template Base Class Members Without “this” Pointer
• Why Does the Compiler Complain?
  • 1. Dependent and Non-Dependent Names
  • 2. Two-Phase Name Lookup in Templates
• Using the this Pointer to Access Template Base Class Members
• Alternative Solution: Using Base<T>::member Notation
• Comparison of this-> vs. Base<T>::member in Template Inheritance
• Conclusion

Importance of Template-Based Inheritance

In template-based inheritance, assigning the proper member ensures the correct compilation and behavior. We can ensure the proper behavior by using this-> and Base<T>:: these help to find the base class members.

Understanding the Problem with Dependent Names in Template Inheritance

In the template definition, the dependent name is a name that depends on the template parameter. During the initial parsing of the template, the compiler cannot resolve the dependent names unless explicitly told how to find them. 

The Problem in Accessing Template Base Class Members Without ‘this’ Pointer

You might face an issue when the members are not directly visible when accessing the members of a template base class inside a derived template class. This occurs because the compiler doesn’t look for names in the dependent base class automatically. To solve this issue, you must explicitly use the this (->) before accessing the members. The this pointer tells the compiler that the member that we assigned belongs to the current instance; without this, the compiler may generate an error by thinking the member is undefined.

Example: 

Output: 

In the above code, the error occurs because Base<T> is a dependent base class i.e., it depends on the template parameter T. When the compiler sees show() within callShow(), it doesn’t immediately go looking for the base class Base<T>, even though the base class depends on a template argument (T). In the first step of template compilation, the base class is only partially processed, and the compiler doesn’t yet know if show() exists. To allow us to do that, we need to use this->show(), to tell the compiler to look in the base class.

Why Does the Compiler Complain?

While accessing a base class member in a template, the compiler mostly does not find the base class member because the base class depends on the template parameter.

1. Dependent and Non-Dependent Names

The compiler delays the resolution until the completion instantiation of dependent names because: 

• The dependent names depend on the template parameter 
• The non-dependent names do not depend on the template parameter. 

Note: Mostly, the non-dependent names are resolved in the starting phase, they do not require this->for proper lookup. 

Example:

Output:

Since the show() in the base class is dependent on the template parameter, the compiler does not find it automatically. That’s why when we use this->show(); it tells our compiler to look in the base class for that function, so it goes and executes that function.

2. Two-Phase Name Lookup in Templates

C++ compiles templates in two passes. 

1. It first checks for syntax errors but does not resolve non-dependent names. 
2. During the second phase (when the template is instantiated), it completely resolves all dependent names.

Example:

Output: 

The problem in the above code is that Derived inherits only from Base, but Base is dependent on a template type, so the compiler did not look for show() in the Base class. The explicit call to show makes the compiler look for show() in the Base class and ensures that it works fine.

Using the this Pointer to Access Template Base Class Members

In a derived template class, we can use this-> for accessing members of a dependent base class. The “this” tells the compiler to check the member of a base class. The absence of this-> may cause issues, like the compiler may not recognize the member due to template compilation rules. So, using this-> memberName makes sure for better look up and avoids errors.

• Assigning the this pointer: this->show();
• Assigning explicit qualification: Base<T>::show();

Example: using this-> to avoid the errors 

Output: 

The above code is the solution for the previous error. Here, we use this-> show() explicitly, which tells the compiler that show() belongs to the Base<T> and should be looked up. 

Alternative Solution: Using Base<T>::member Notation

The alternative to this-> show() is Base<T>::show*(). This alternative method directly tells the compiler to find the show() in the base class. Although this->show() is typically used for non-static cases, Base<T>:: show() is used for static and non-virtual functions.

Comparison of this-> vs. Base<T>::member in Template Inheritance

Conclusion

The members from base classes won’t be visible without this-> or Base::member when using template-based inheritance. Otherwise, a compilation error will be shown; this-> guarantees proper lookup and thus preserves polymorphism, while Base::member works well for static or explicitly specified member functions. Both techniques assist the compiler in correctly resolving dependent names. This prevents template instantiation problems and provides behavioral correctness.

You can learn more about C++ in the C++ article, and also explore C++ Interview Questions prepared by industry experts.

FAQs