С++: как требовать, чтобы один тип шаблона был получен из другого

Ответ 1

Вы можете выглядеть так:

template <typename B, typename D>
struct is_base_of // check if B is a base of D
{
    typedef char yes[1];
    typedef char no[2];

    static yes& test(B*);
    static no& test(...);

    static D* get(void);

    static const bool value = sizeof(test(get()) == sizeof(yes);
};

Тогда вам просто нужно какое-то статическое утверждение:

// really basic
template <bool>
struct static_assert;

template <>
struct static_assert<true> {}; // only true is defined

#define STATIC_ASSERT(x) static_assert<(x)>()

Затем поместите их вместе:

template<class R1, class R2>
bool operator==(Manager<R1> m1, Manager<R2> m2)
{
    STATIC_ASSERT(is_base_of<R1, R2>::value || is_base_of<R2, R1>::value);

    return p1.internal_field == p2.internal_field;
}

Если один не получается из другого, функция не будет компилироваться. (Ваша ошибка будет похожа на "static_assert<false> not defined", и она укажет на эту строку.)

Ответ 2

Вы можете использовать boost typetraits (is_base_of) и повысить enable_if.

#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>

template <class R1, class R2>
struct has_derived_base_relationship :
    boost::integral_constant<
        bool, boost::is_base_of<R1, R2>::value || boost::is_base_of<R2, R1>::value 
    >
{};

template<class R1, class R2>
typename boost::enable_if<has_derived_base_relationship<R1, R2>, bool>::type 
operator==(Manager<R1> m1, Manager<R2> m2) {
    return p1.internal_field == p2.internal_field;
}

С другой стороны, почему использование operator == имеет большее значение с типами одного дерева наследования? Разве не нужно было бы использовать двойную отправку для достижения значимых результатов?

Ответ 3

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

Как и в boost, для этой задачи могут быть применены специализированные шаблоны, на самом деле вы можете определить структуру шаблона, содержащую операции над данным типом, и использовать вложенные шаблонные структуры для этих операций. В нашем случае:

// Working on a specific type:
template <typename T1>
struct is_type {
    // For all types T2!=T1 produce false:
    template <typename T2>
    struct same_of { static const bool value = false; };
    // Specialization for type T2==T1 producing true:
    template <>
    struct same_of<T1> { static const bool value = true; };
};

Определение макроса позволяет легко использовать его:

#define is_type_same(T1,T2) (is_type<T1>::same_of<T2>::value)

следующим образом:

template<class R1, class R2>
bool operator==(Manager<R1> m1, Manager<R2> m2) {
    return is_type_same(R1,R2) && m1.internal_field == m2.internal_field;
}

Ответ 4

Если concept s был бы включен в С++ 0x, вы могли бы использовать их с компилятором, который реализует их (например, gcc).

Как это ни в коем случае, единственной альтернативой, доступной в настоящее время для того, чтобы сделать то, что вы хотите, является библиотека поддержки Boost Concept.

Ответ 5

template<class T, class B> struct Derived_from {
 static void constraints(T* p) { B* pb = p; }
 Derived_from() { void(*p)(T*) = constraints; }
};

template<class R2, class R1>
bool test(R1& r1) {
 Derived_from<R1,R2>(); // accept if R1 is derived from R2
 return false;
}

class Base {
public:
 virtual ~Base() { }
};

class Derived : public Base {

};

class Other {

};

int _tmain(int argc, _TCHAR* argv[])
{
 Derived d;
 Other o;

 test<Base>(d); // OK
 test<Base>(o); // Fails in VC++ 2005

 return 0;
}

Кредиты переходят на http://www2.research.att.com/~bs/bs_faq2.html#constraints

Ответ 6

Я должен признать, что я не вижу мотивации, особенно если это требует написания shedloads поддерживающего кода. Для вашего оператора:

template<class R1, class R2>
bool operator==(Manager<R1> m1, Manager<R2> m2) {
    return p1.internal_field == p2.internal_field;
}

для компиляции без предупреждения, оба типа параметров шаблона должны быть способны к параметрам шаблона менеджера, и эти типы должны иметь закрытые члены (я предполагаю, что p1 и p2 должны быть m1 и m2), называемые internal_field. Учитывая эти ограничения, какова вероятность того, что эта функция шаблона может быть вызвана случайно на неправильном типе (типах)?