Name lookups in C++ templates

Question

I have some C++ code that is no longer compiling without the -fpermissive option. It\'s propriety code that I can\'t share, but I\'ve think I\'ve been able to extract a simp

Answer 1

You need to write this-> as:

this->next(item);

Here this-> part is required because next() is an inherited member from template base, and if you read the error message carefully, it is suggested there itself:

template_eg.cpp:18:25: note: declarations in dependent base 'List<int>' are not found by unqualified lookup
template_eg.cpp:18:25: note: use 'this->next' instead

Read this article which has explained two-phase name lookup in C++:

• The Dreaded Two-Phase Name Lookup

Answer 2

The problem is that templates are processed in two passes (according to the standard, VS does otherwise). In the first pass, before the type substitution, everything that does not depend on the template arguments is looked up and checked. Dependent names are then left to resolve in the second pass, once the type has been substituted.

Now, in the first pass there is nothing that indicates that next is dependent on template arguments, and thus it needs to resolve before type substitution. Now, because the base type is templated on the template argument of your current template, the compiler cannot look into it (it might be specialized for some types, and without knowing what type T we are instantiating the template with, we cannot know which specialization to use, i.e. the base depends on T and we are checking before knowing T).

The trick of adding this-> turns next into a dependent name, and that in turn means that lookup is delayed until the second pass, where T is known, and because T is known, List<T> is also known and can be looked up into.

---

EDIT: One important detail missing in the wording of the answer above is that second phase lookup (after type substitution) will only add functions found during argument dependent lookup. That is, if next was a free function in a namespace associated with T it would be found, but it is a member on the base, which is not visible for ADL on T.

Answer 3

If your base class is a template instance, then there's no way to know that next refers to a name in the base class -- after all, the name needn't even exist (think about specializations)! Thus, you have to assert to the compiler that next is actually a class member by saying this->, or List<T>::next, or by prepending using List<T>::next; to your derived class template.