Как проверить, является ли класс B производным от семейства шаблонов классов

Как проверить во время компиляции, является ли класс B производным от std::vector?

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

Как проверить во время компиляции, является ли класс B производным от семейства шаблонов?

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

С использованием:

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
}

c++ templates sfinae typetraits c++03
person Alexey Malistov    schedule 29.08.2012    source источник
comment
При метапрограммировании шаблонов важно четко указать, нужен ли вам только C++03 или решение C++11 является хорошим (хотя я не уверен, что C++11 может здесь помочь). И как умное замечание, учитывая, что вы никогда не должны наследовать от стандартных контейнеров, исходная черта проста: false :P   -  person David Rodríguez - dribeas    schedule 29.08.2012
comment
С++ 03. Я использую компилятор msvc 2010. Поэтому я согласен использовать decltype дополнительно. std::vector это например один. Если вы не знаете решение C++03, то решение C++11 также приветствуется.   -  person Alexey Malistov    schedule 29.08.2012

Ответы (3)


arrow_upward
12
arrow_downward

Попробуй это:

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

Использование:

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

Примечание: В строке, помеченной #1, вы также можете заставить свой трейт принимать любой шаблон, который имеет хотя бы один, но, возможно, и больше аргументов типа, написав:

template <typename, typename...> class Tmpl
person Kerrek SB    schedule 29.08.2012
comment
Если вы используете template<typename...>class Tmpl и используете пакет параметров для своей тестовой функции, вы также должны иметь возможность обрабатывать шаблон с любым количеством аргументов, а не только с одним. - person Dave S; 29.08.2012
comment
Проблема с этим подходом в том, что он будет работать только для шаблонов с одним аргументом. Даже если вы дополните его, чтобы он принимал два обычных аргумента std::vector, реализации разрешено добавлять дополнительные параметры шаблона (при условии, что для этих параметров предоставляются значения по умолчанию), поэтому он не будет на 100% переносимым. - person David Rodríguez - dribeas; 29.08.2012
comment
@Oktalist: Не могли бы вы опубликовать контрпример? У меня есть идея, как я могу это исправить, если проблема действительно существует. - person Kerrek SB; 12.08.2014
comment
Виноват. §14.8.2.1(4) содержит специальное правило, которое позволяет дедукции аргумента шаблона вывести simple-template-id, который является базовым классом типа аргумента. Нет такого правила для пользовательских конверсий. - person Oktalist; 13.08.2014

arrow_upward
1
arrow_downward

У меня была такая же ситуация, когда мне нужно было знать, является ли класс производным от векторного (подобного) класса. К сожалению, в моем проекте не разрешены макросы C++-11 или вариативные макросы. Итак, мое решение представляло собой смесь ответа Керрека и этого статья с кодом googletest в конце:

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

Я думаю, что общее решение для любых шаблонов было бы невозможно определить без использования C++-11 или выше.

person michael_s    schedule 12.08.2014

arrow_upward
0
arrow_downward

Я искал решение этой проблемы не так давно и после консультации с

Современный дизайн C++: применение общих шаблонов программирования и проектирования

Мне удалось построить следующее, более или менее похожее на то, что было представлено в комментариях.

#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;
}
person mkmostafa    schedule 21.08.2017