How to test whether class B is derived from template family of classes

Question

How to test at compile time whether class B is derived from std::vector?

template<class A>
struct is_derived_from_vector {
  static const bool value = ????;
};

How to test at compile time whether class B is derived from template family?

template<class A, template< class > class Family>
struct is_derived_from_template {
  static const bool value = ????;
};

Using:

template<class T> struct X {};

struct A : X<int> {}
struct B : std::vector<char> {}
struct D : X<D> {}

int main() {
   std::cout << is_derived_from_template<A, X>::value << std::endl; // true
   std::cout << is_derived_from_template<D, X>::value << std::endl; // true
   std::cout << is_derived_from_vector<A>::value << std::endl; // false
   std::cout << is_derived_from_vector<B>::value << std::endl; // true
}

Answer 1

Try this:

#include <type_traits>

template <typename T, template <typename> class Tmpl>  // #1 see note
struct is_derived
{
    typedef char yes[1];
    typedef char no[2];

    static no & test(...);

    template <typename U>
    static yes & test(Tmpl<U> const &);

    static bool const value = sizeof(test(std::declval<T>())) == sizeof(yes);
};

Usage:

#include <iostream>

template<class T> struct X {};

struct A : X<int> {};

int main()
{
    std::cout << is_derived<A, X>::value << std::endl;
    std::cout << is_derived<int, X>::value << std::endl;
}

Note: In the line marked #1, you could also make your trait accept any template that has at least one, but possibly more type arguments by writint:

template <typename, typename...> class Tmpl

Answer 2

I had the same situation that I needed to know if a class is derived from a vector(like)-class. Unfortunately there is no C++-11 or variadic macros allowed in my project. So my solution was a mixture of Kerrek's answer and this article with some googletest-code at the end:

#include <vector>

template <typename T>
class is_derived_from_vector
{
    typedef char Yes_t[1];
    typedef char No_t[2];

    static No_t& test(const void* const);

    template <typename U>
    static Yes_t& test(const std::vector<U>* const);

public:
    static const bool value = ((sizeof(test(static_cast<T*>(0)))) == (sizeof(Yes_t)));
};

template<class T> struct X {};
struct A : X<int> {};
struct B : std::vector<char> {};

TEST(Example, IsDerivedFrom)
{
   EXPECT_FALSE(is_derived_from_vector<A>::value);
   EXPECT_TRUE(is_derived_from_vector<B>::value);
}

A common solution for any templates I think would not be possible to define without usage of C++-11 or higher.