How to write a template specialization of a type trait that works on a class template?

Question

Let's consider the following CRTP code, with the slight modification that the derived class has to be a template one:

template<template<typename> class DERIVED, typename T>
struct crtp_base {};

template<typename T>
struct derived : crtp_base<derived,T>  {};

I would like to define a type trait telling whether a class is derived from the CRTP base class. In other words, I need a type trait that works on a class template (and not on a type).

The first approach would be to define a generic version of the trait, with the peculiarity that the parameter is a template template one:

template<template<typename> class DERIVED> 
struct is_crtp_based : std::false_type {};

Now, a first attempt for the template specialization of interest:

template<template<typename> class DERIVED, typename T>
struct is_crtp_based <crtp_base<DERIVED,T>> : std::true_type {};

but the compiler is not happy with this since it expects a class template but it finds a (non template) class crtp_base<DERIVED,T> instead.

Question: how should one write the specialization in such a case ? More generally, how to deal with type traits that take a class template as parameter ? I guess that there are already existing use cases like this but I don't find any of them right now.

Note: I can solve the question by the following trait that uses std::is_base_of :

template<template<typename> class DERIVED, typename T=void>
struct is_crtp_based : std::integral_constant<bool, std::is_base_of_v<crtp_base<DERIVED,T>,DERIVED<T> >> {};

static_assert (is_crtp_based<derived>::value == true);

but I would like to understand how to correct my first incorrect attempt through template specialization.

UPDATE: For a little bit more context, the crtp_base needs to know the T type, which explains the T template parameter in its definition and makes all the remaining more difficult (see my comment to 463035818_is_not_an_ai's answer).

Answer 1

I dare to claim that what you actually want is this:

template<typename DERIVED>
struct crtp_base {};

template<typename T>
struct derived : crtp_base<derived<T>>  {};

To check whether a type derives from an instantiation of crtp_base you can use

template <typename T>
using is_crtp = std::is_base_of<crtp_base<T>,T>;

And thats it.

---

No need for complicated template template arguments.

---

You want T to be available in the crtp base? Ok, write a trait for that:

template <typename T> 
struct get_T;

template <template <typename> class X,typename T>
struct get_T<X<T>> {
    using type = T;
};

Now get_T< derived<T>>::type is T. In your base you can use get_T<DERIVED>. There is a template template argument, but only in one place, not all over your code.

Note that the get_T is rather limited, it only works for templates with a single type argument. Though tahts exactly the same limitation as in your version of crtp_base.

Answer 2

Primary templates and specializations have template arguments that are a different kind of thing.

template<template<typename> class DERIVED> 
struct is_crtp_based;

in the primary template, you are saying what the category of arguments are. Here, we are passing not a type but a template as its one argument.

is_crtp_based <crtp_base<DERIVED,T>> 

and here, you are passing a type to is_crtp_based!

You need to think of templates classes as a different kind of thing than types.

template<class T> struct foo;

foo is a template class, a factory of types. foo<int> is a type. They have a relationship similar to types and variables, but 1 level of abstraction higher.

int

is a type

int x;

is a variable of type int.

foo

is a template class

foo<int>

is a type instantiation of the template class.

In your case, you want to pass a type to

template<template<typename> class DERIVED> 
struct is_crtp_based;

so the primary template needs to take a type:

template<class T> 
struct is_crtp_based:std::false_type{};

we'll derive the trait from false_type - by default, it stuff doesn't qualify.

Now to handle the actual thing

template<template<class...>class Z, class...Ts>
struct is_crtp_based<Z<Ts...>>:std::true_type{};

we probably aren't detecting what you want, but this matches types against being a template instantiation, where that template takes only types.

So

is_crtp_based<foo<int>>

that is truthy.

Now, in your case, you want to mess around with base types. A problem is that template traits do not inspect the base type! Examining base types is a property of inheritance, and inheritance lookups happen with template function selection during overload resolution, not in trait classes.

So we'll have to start over and do this with template functions, then use the result and make a trait.

We'll start with a C-style variardic function. We do this because it has a really low priority for selection during overload resolution:

constexpr std::false_type is_crtp_based_ptr(...) { return {}; }

then we pattern match:

template<template<class...>class Z, class T, class...Ts>
constexpr std::true_type is_crtp_based_ptr( T const volatile*, Z<T, Ts...> const volatile* ) { return {}; }

so far so good. For this case:

template<class D, class...Ts>
struct base {};
struct derived: base<derived, Ts...> {};

we can check:

is_crtp_based_ptr( (derived*)0, (derived*)0 )

and it should return true_type if I wrote it right.

This doesn't match your funny template restriction case, but we can augment:

template<template<class...>class X, class... Xs, template<template<class...>class, class...>class B, class...Ts>
constexpr std::true_type is_crtp_based_ptr( X<Xs...>* derived, B<X, Ts...>* base ) { return {}; }

which should catch:

template<template<class>class D, class...Ts>
struct base {};
template<class T>
struct derived: base<derived, T> {};

similarly.

I will, however, seriously doubt that you want to pass the template and not the type to your CRTP base.

Answer 3

Your starting point for is_crtp_based is too complicated. A simple solution is to just use some instance of the template to test the inheritance on a specific type:

template<template<typename> class DERIVED, typename T>
struct crtp_base {};

template<typename T>
struct derived : crtp_base<derived,T>  {};

template<template<typename> class DERIVED, typename TestOn = int> 
struct is_crtp_based : std::is_base_of<crtp_base<DERIVED, TestOn>, DERIVED<TestOn> > {};

template<template<typename> class DERIVED, typename TestOn = int>
constexpr bool is_crtp_based_v = is_crtp_based<DERIVED, TestOn>::value;

https://godbolt.org/z/7bK39a7fY