Comment tester si la classe B est dérivée d'une famille de classes de gabarits

Question

Comment tester au moment de la compilation si la classe B est dérivée de std::vector ?

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

Comment tester au moment de la compilation si la classe B est dérivée de la famille des modèles ?

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

Utilisation :

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

Essayez ça :

#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);
};

Utilisation :

#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 : Dans la ligne marquée #1 vous pouvez également faire accepter votre trait tout qui a au moins un, mais éventuellement plusieurs arguments de type par writint :

template <typename, typename...> class Tmpl

Answer 2

J'ai été confronté à la même situation : j'avais besoin de savoir si une classe est dérivée d'une classe vectorielle. Malheureusement, mon projet ne permet pas l'utilisation de C++-11 ou de macros variadiques. Ma solution était donc un mélange de La réponse de Kerrek et ceci article avec du code googletest à la fin :

#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);
}

Je pense qu'une solution commune pour tous les modèles ne serait pas possible à définir sans l'utilisation de C++-11 ou plus.

Answer 3

Il y a peu de temps, je cherchais une solution à ce problème et après avoir consulté

Modern C++ Design : Programmation générique et modèles de conception appliqués

J'ai pu construire ce qui suit, qui est plus ou moins similaire à ce qui a été fourni dans les commentaires.

#include <iostream>
#include <type_traits>
#include <utility>

template <typename T, template <typename...> class U>
struct is_derived
{
private:
    template <typename...Ts>
    static constexpr std::true_type check(const U<Ts...>&);
    static constexpr std::false_type check(...);

    template <typename>
    struct is_same
    {
        static constexpr bool value = false;
    };

    template <typename...Ts>
    struct is_same <U<Ts...>>
    {
        static constexpr bool value = true;
    };

  public:
    static constexpr bool value =
        std::is_same<decltype(check(std::declval<T>())),
                     std::true_type>::value &&
        !is_same<T>::value;
};

template <typename, typename>
struct X
{
};

template <typename T>
struct Y : X <T, int>
{
};

int main(int argc, char **argv) {

    std::cout << std::boolalpha << is_derived<Y<int>, X>::value << std::endl;
    std::cout << std::boolalpha << is_derived<X<int,int>, X>::value << std::endl;
    std::cout << std::boolalpha << is_derived<int, X>::value << std::endl;

  return 0;
}