What you are using in this case is called injected class name. Inside some invented template class ‘SomeClass’ injected name ‘SomeClass’ refers to the current specialization of SomeClass template. However, this injected name obeys the same rules as any other nested type declaration.

In particular, when you refer to a nested name of a class type that happens to be a _dependent_ type (i.e. a type that depends on some yet-unknown template parameters), you have to use the keyword `typename` to refer to that nested type.

This is exactly the reason for the problem in your case. The inherited name `Shape` is a nested name of class `NA::NB::NC::Shape`. The latter still depends on a template parameter `A` (the other parameters are “fixed”, but `A` is still unknown). So, the error you are observing is essentially the same as the one in this case

tempate  struct S { using type = T; }
template  struct X
{
  using A = S::type; 
  // ERROR: `S` is a dependent type, keyword `typename` is required!

  using B = typename S::type; 
  // OK, this is the correct form

  using C = S::type; 
  // OK, `S` is not a dependent type, so `typename` is not needed
}

The problem is not that your derived class is template. The problem is that your base class still depends on template parameter `A`, which makes it a dependent type and which enables this `typename` requirement. Unfortunately, there’s no “short” syntax for this.

In C++ declarations of class member are separated into two distinctive groups. Declarations from one group can only see the portion of the class declared _above_ them. Declarations from the other group can always see the class in its entirety, including what’s declared below. This latter group is what will definitely have serious issues with this approach to declaring `base_type`.

For example, definitions of class member functions will always see the class a fully defined, in its entirety, regardless of where the function definition is placed (in-class or out-of-class). So, in your case any member function body of class `Shape` will see `base_type` as an alias for `Shape` itself. What do you think will happen in member functions definitions like

void Shape::draw() const override
{
base_type::draw();
}

Yes, you guessed it: this function actually calls itself. It is infinitely recursive.

So, please, be very careful with this “Boost Spirit” approach – it has a very limited usability in some very well controlled contexts. It is not viable for general use.

In C++ declarations of class member are separated into two distinctive groups. Declarations from one group can only see the portion of the class declared _above_ them. Declarations from the other group can always see the class in its entirety, including what’s declared below. This latter group is what will definitely have serious issues with this approach to declaring `base_type`.

For example, definitions of class member functions will always see the class a fully defined, in its entirety, regardless of where the function definition is placed (in-class or out-of-class). So, in your case any member function body of class `Shape` will see `base_type` as an alias for `Shape` itself. What do you think will happen in member functions definitions like

void Shape::draw() const override
{
base_type::draw();
}

Yes, you guessed it: this function actually calls itself. It is infinitely recursive.

So, please, be very careful with this “Boost Spirit” approach – it has a very limited usability in some very well controlled contexts. It is not viable for general use.

Interesting! I’m not sure why TBH. Maybe this has something to do with ignored names in template base classes. But even this, I’d have thought this would only be about the names inside of the base class.

You are right. It works. However it doesn’t work when the derived class is a template

https://wandbox.org/permlink/yFLkuhvu5amayAoq

Wondering why?

Hey Vincente, it seems to work with clang and gcc, as in this example: http://coliru.stacked-crooked.com/a/40996a85a52fa109. Is that the code that you had in mind?

I prefer to define it on the derived class as it is there where the base_type name has a sense, not on the base class. You need to write the base class name twice however.

class Oval : public NA::NB::NC::Shape
{
using base_type = Shape;

I’m getting this error

error: use of class template ‘Shape’ requires template arguments

Which compiler are you using?

Have you tried with clang or gcc?

Are you sure this should work?

Yes, it’s more direct and explicit. But indexes are shorter. Anyway both cases could be implemented with variadic templates (using two standard techniques). The only change you should do in derived class is to replace ‘class C : public A, B’ to something like ‘class C : public inherit<A, B>’.

“base” sounds good to me for single inheritance. In the case of multiple inheritance, isn’t it more direct to access the base classes by their names?