Template class inheritance from a different specialization

Question

This is a question out of curiosity on C++ rules without any real practical usage. When toying around with templates, I created a class hierarchy like so:

#include <stdio.h>

// Declaration
template <int X = 0>
struct A;

// Specialization for X = 0
template <>
struct A<0>
{
    virtual void foo()
    {
        printf("A<0>::foo()\n");
    }
};

// Extended generalized implementation
template <int X>
struct A : public A<0>
{
    virtual void foo()
    {
        printf("A<1>::foo()\n");
    }

    virtual void bar()
    {
        printf("A<1>::bar()\n");
    }
};

int main()
{
    A<> a0;
    A<1> a1;

    a0.foo();
    a1.foo();
    a1.bar();

    return 0;
}

This code compiled fine on Visual Studio and produces the expected output:

A<0>::foo()
A<1>::foo()
A<1>::bar()

Is this a valid C++ design practice? It certainly looks strange to me, so I'm wondering if this is some sort of undefined behaviour which just happens to work depending on compiler with lots of pitfalls and gotchas, or if it is a well-defined usage of templates.

It would be interesting to see any practical examples of this.

Answer 1

This is a standard technique that is quite often used when defining a template recursively.

An example of such a technique would be sequences of integers:

template<int...s> struct seq {typedef seq<s...> type;};

In particular, in their generation:

template<int max, int... s> struct make_seq:make_seq<max-1, max-1, s...> {};
template<int... s> struct make_seq<0, s...>:seq<s...> {};

which is described recursively and simply by inheriting from a different instantiation of the template.

To be explicit, make_seq<7>::type is seq<0,1,2,3,4,5,6> via 7 levels of recursive inheritance.

Answer 2

This is valid as far as C++ is concerned. A class template A<1> is an entirely different animal from another class template A<0>.

In fact, what you have built here looks similar to what is called the Curiously Recurring Template Pattern.