模板类不会看到继承的模板成员

Question

Let me consider a template class which derived from a base template class. The base class contains a template member. In this case, usually members of the base class can be accessed from the derived class using the pointer this . It appears however that this is not the case, when a base member is itself a template function.

Consider the following code

#include <iostream>

template <class T>
struct base {
  T x;
  base() { x = 10; }
  template <unsigned int N>
  void increment() { x += N; }
};

template <class T>
struct deriv : public base<T> {
  using base<T>::base;

  void p()
  {
    using namespace std;
    cout << this->x << endl;
    base<int>::increment<1>();
    // The following statement causes the compile error:
    // expected primary-expression before ‘)’ token
    // this->increment<1>();
    // Also the following statement gives error
    // base<T>::increment<1>();
    cout << this->x << endl;
  }
};

int main()
{
  using namespace std;

  base<int> A;
  cout << A.x << endl;
  A.increment<1>();
  cout << A.x << endl;

  deriv<int> B;
  B.p();

  return 0;
}

In the main routine the template member increment is called from a variable of type base . This works without any problem. On the other hand, the member function p() of the deriv class tries to access to the template function increment inherited from base. Using the pointer this as in the commented line above

this->increment<1>();

gives the compile error

expected primary-expression before ‘)’ token

After trying for a while, I found it possible, as in the code above, to access to the increment function via the scope operator

base<int>::increment<1>();

This however explicitly instantiate base with T=int . If I want to call the increment member from the inherited base<T> , with generic T class as

base<T>::increment<1>();

I get the same error as above.

I am using gcc 8.1.1

The question is: why using the pointer this cannot the compiler resolve the inherited member function increment ? How can I get instantiate the inherited template function increment , from the inherited class base ?

Edit: I added another case where it fails to compile, better specify the question.

Edit: small correction in the program, same question.

Answer 1

Unless you specify otherwise, the compiler assumes that the name you access is not a template, so both < and > are tokenized as less than and greater than signs respectively (the line is parsed as ((this->increment)<1)>() ). This happens because this and base<T> are both dependent on the template parameter T and the compiler cannot look up increment to see if it is a template. This holds for any case where the name on the left of an operator is dependent on any template parameter and the name on the right is template-id (name with <> ). To solve this problem, you need to use the template keyword

base<T>::template increment<1>();
this->template increment<1>();

Why does base<int>::increment<1>(); compile then? Because it does not depend on T (refers to a known specialization), thus the name increment can be looked up to determine whether it is or is not a template.
But it won't compile if T is not int . gcc gives the following error
[x86-64 gcc 8.1 #1] error: type 'base<int>' is not a base type for type 'deriv<long long int>'
If base<int>::increment was public static, the code would always compile (not exactly because the compiler would compile about x not being static, but with additional changes it would).

Answer 2

Calling this->increment<1>() is invalid because increment is a dependent function template. You need therefore need to use the template keyword:

this->template increment<1>();

Your using directive and base<int>::increment<1>() call are also not correct. If deriv is intantiated with a type other than int neither of those will work. You should use T instead of int in both of those. When doing so the call to base<T>::increment<1>() will become invalid for the same reason this->increment<1>() is invalid. You need the template keyword there as well:

base<T>::template increment<1>();