Make sure that typename type is a Derived of Base

Question

I've this kind of code

template <typename D, typename T>
class tl1 {
    std::list<T> mTs ;
public:
    T & getTbyName() const ;
}

template <typename T, typename C>
class tl2 {
public:
    std::string getName() { return mName ; }
private:
    C & mC ;
    std::string mName
}

class c2 ;

class cl1 : tl1<cl1, cl2>  {

}
class cl2 : tl2<cl2, cl1>  {

}

How could I check (at compile time) that T is cl2 type or derived from cl2 and C is cl1 type or derived from cl1. I need to be sure about cl2 type or the getTbyName will be a mess.

Thank you for your time
Quentin

Answer 1

You may use static_assert and std::is_base_of.

#include <type_traits>

struct B {};

template <typename T>
class C {
    static_assert(std::is_base_of<B, T>::value, "T should inherit from B");
};

struct D : public B {};
struct KO {};


template class C<B>;
template class C<D>;
template class C<KO>;

int main()
{
}

---

main.cpp: In instantiation of 'class C<KO>':
main.cpp:16:16:   required from here
main.cpp:7:5: error: static assertion failed: T should inherit from B
     static_assert(std::is_base_of<B, T>::value, "T should inherit from B");
     ^
======= clang =======
main.cpp:7:5: error: static_assert failed "T should inherit from B"
    static_assert(std::is_base_of<B, T>::value, "T should inherit from B");
    ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.cpp:16:16: note: in instantiation of template class 'C<KO>' requested here
template class C<KO>;
               ^

Online Demo

Answer 2

Use std::is_base_of from <type_traits> in conjunction with std::enable_if:

template <typename T,
  typename = typename std::enable_if<std::is_base_of<cl2, T>::value>::type>
class cl1 {
    std::list<T> mTs ;
}

Answer 3

When you want to figure out if A is a base of B, your compiler needs to know the type definitions or A and B must be the same (A is a base of A).

So you want to check if one template argument is derived from a forward declared type.

Judging from your later post, you also want to check that your CRTP base classes are actually used as base classes to one of the arguments.

In the latter case, the compiler does not have all the information when the CRTP base class is specialized, because the derived class has not been defined.

Thus, you have to defer the evaluation until a later stage, when the compiler has the necessary information. To do this, let's create a helper:

#include <utility>

class cl2;
class cl1;

template <typename Defer, typename Base, typename Derived>
struct deferred_is_base_of : std::is_base_of<Base, Derived>
{
};

In theory, this class could be specialized later on, so the compiler can not assume that defered_is_base_of is the same as std::is_base_of.

Assuming that we need a constructor (any other "required" function would also be OK):

template <typename Derived, typename Value>
class tl1
{
public:
  template <typename Defer = void>
  tl1()
  {
    static_assert(deferred_is_base_of<Defer, cl2, Value>::value,
                  "Value has to be derived from cl2");

    static_assert(deferred_is_base_of<Defer, tl1, Derived>::value,
                  "Derived has to be derived from tl1");
  }
};

The constructor is a template with a default parameter. Thus, you can call it like always. But the compiler has to wait for you to do it because you might use a different template parameter.

This does the trick. The compiler will evaluate the static assert only when the constructor is called. And by then, there will be enough information.

The second template works the same way:

template <typename Derived, typename Value>
class tl2
{
public:
  template <typename Defer = void>
  tl2()
  {
    static_assert(deferred_is_base_of<Defer, cl1, Value>::value,
                  "Value has to be derived from cl1");

    static_assert(deferred_is_base_of<Defer, tl2, Derived>::value,
                  "Derived has to be derived from tl2");
  }
};

class cl1 : tl1<cl1, cl2>
{
  cl1()
  {
  }
};

class cl2 : tl2<cl2, cl1>
{
  cl2()
  {
  }
};

int main() {}

Deferring template evaluation is a powerful tool in your TMP toolbox.

EDIT: As @Brandon pointed out, the deferred base of is not required here. It is enough to put the check into the constructor to defer here.