Question

I’m trying to create an is_foo function, that I can then use with enable_if, to determine if a type is derived from a certain CRTP base class. The code below is my attempt at implementing the is_foo function, but it doesn’t actually work. Could someone tell me what I need to change to fix it?

Thanks.

#include <iostream>
#include <type_traits>
#include <functional>

using namespace std;

template <class Underlying, class Extra>
struct Foo
{
    int foo() const { return static_cast<const Underlying*>(this)->foo(); }
};

template<class T>
struct Bar : Foo<Bar<T>, T>
{
    int foo() const { return 42; }
};

template<class T>
struct is_foo { static const bool value = false; };

template<class Underlying, class Extra>
struct is_foo<Foo<Underlying, Extra> > { static const bool value = true; };

template<class T>
void test(const T &t)
{
    cout << boolalpha << is_foo<T>::value << endl;
}

int main()
{
    Bar<int> b;
    test(b);
}

Answer 1

Add a typedef to the Foo base:

template < typename Derived >
struct crtp
{
  ...
  typedef int is_crtp;
};

Implement a has_field check:

BOOST_MPL_HAS_XXX(is_crtp)

Implement your metafunction:

template < typename T >
struct is_crtp_derived : has_is_crtp<T> {};

This is the only way I can think of that will correctly catch grandchildren. It’s prone to false positives though so you’ll want to pick your names to be too obnoxious to be accidentally used elsewhere. Your other option would be to implement your metafunction in terms of is_base_of:

template < typename T >
struct is_crtp_derived : std::is_base_of< crtp<T>, T> {};

This of course won’t catch grandchildren.