1

I just discovered in an answer here that a template can inherit from itself - given sufficient defined full specializations. As seen, for example, here (and live on wandbox):

#include <iostream>
#include <string>

template <typename T>
struct Foo : public Foo<decltype(T::x)> {};

template <typename TT>
struct Foo<TT*> {
  TT* p;
};

template <typename TT>
struct Foo<TT&> {
  TT r;
};

struct Has_x {
  std::string* x;
};

int main()
{
    std::string s{"I'm 's'"};
    Foo<Has_x> foo_has_x;
    foo_has_x.p = &s;

    std::cout << typeid(foo_has_x).name() << " - " << *foo_has_x.p << std::endl;
}

(Example works for C++11 and on.)

I had no idea that was possible. It's kind of an twisted cousin of CRTP. But anyway, now I'm wondering how it can be used - or has been used.

Obviously, the answer linked above (by Columbo) was a very nice use case: Be able to find the argument types and return types of a (non-generic) functor or lambda. (And it does that by providing specializations suitable for function signatures, and inheriting using the decltype of its type parameter's operator().)

But what else can it be/has it been used for? Perhaps something not decltype-of-a-member-ish?

Also, what limitations are associated with this? I don't see, for example, how to deal (nicely, meaning by providing defaults) with any case that is not fully specialized. Your full specializations need to cover all cases. Can you provide a default case? Are there other limitations to be aware of?

davidbak
  • 5,775
  • 3
  • 34
  • 50
  • default is the primary template... You mght still have this kind of inheritance somewhere else as `template struct Bar; template struct Bar : Bar{};`. – Jarod42 Jan 12 '21 at 23:24
  • 1
    *"that is not fully specialized"*, your snippet, as the linked code use **partial** specialization, fully specialization is for type such as `template <> struct Bar> {};`. – Jarod42 Jan 12 '21 at 23:28

0 Answers0