В операторе сравнения:
template<class R1, class R2>
bool operator==(Manager<R1> m1, Manager<R2> m2) {
return m1.internal_field == m2.internal_field;
}
Можно ли каким-либо образом обеспечить, чтобы R1 и R2 имели отношение супертипа или подтипа? То есть, я хотел бы разрешить вывод R1 из R2 или R2, который должен быть получен из R1, но запретить сравнение, если R1 и R2 являются несвязанными типами.
Вы можете выглядеть так:
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", и она укажет на эту строку.)
Вы можете использовать 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 == имеет большее значение с типами одного дерева наследования? Разве не нужно было бы использовать двойную отправку для достижения значимых результатов?
В этом сообщении я рассматриваю проблему проверки того, соответствует ли тип точно другому, это не совсем то, что требуется, но это проще, и я надеюсь, что это поможет понять применяемые шаблонные трюки.
Как и в 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;
}
Если concept s был бы включен в С++ 0x, вы могли бы использовать их с компилятором, который реализует их (например, gcc).
Как это ни в коем случае, единственной альтернативой, доступной в настоящее время для того, чтобы сделать то, что вы хотите, является библиотека поддержки Boost Concept.
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
Я должен признать, что я не вижу мотивации, особенно если это требует написания 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. Учитывая эти ограничения, какова вероятность того, что эта функция шаблона может быть вызвана случайно на неправильном типе (типах)?