模板运算符重载中的类型冲突

Question

很抱歉，这听起来像是一个常见问题，就我所见，我找不到问题的答案。最接近的帖子是这个：Template Specialization for basic POD only

假设我有一个类template <class T> class A {...};，我想将 operator+ 重载为内部二元运算符（A 类型的两个对象）和混合二元运算符（A 类型的对象和数字 POD 类型）。

理想情况下，我想写的是：

#include <type_traits>
using namespace std;

// Declare/fine template
template <class T> class A {...};

// Internal binary operator
template < class T, class U >
    A< typename common_type<T,U>::type >
operator+ ( const A<T> &a, const A<U> &a ) { ... }

// Mixed binary operator
template < class T, class U >
    A< typename common_type<T,U>::type >
operator+ ( const A<T> &a, const U &b ) { ... }

但是看起来第二个定义与第一个定义相冲突。使用第二个定义，我知道如何确保 U 是数字 POD 类型，这不是重点。如果我这样做，问题是我无法知道 U 中包含的底层模板类型是否是某个 A。

如果我的问题不够清楚，请告诉我，提前感谢！ :)

编辑：模板规范被 HTML 过滤器清除了，在我的最后一句“U if it is some A<T>”中。简而言之，我是说 T 是隐藏的。

Answer 1

您可以使用一些辅助特性使其工作，以区分 A 的特化与更一般的类型：

#include <type_traits>


// "A" template    

template <typename> class A {};


// Traits for "A-ness":

template <typename> struct is_a : std::false_type { };
template <typename T> struct is_a<A<T>> : std::true_type { };


// Operators:

template <class T, class U>
A<typename std::common_type<T, U>::type>
operator+(const A<T> & a, const A<U> & b);

template <class T, class U,
          typename = typename std::enable_if<!is_a<U>::value>::type>
A<typename std::common_type<T, U>::type>
operator+(const A<T> & a, const U & b);

这会立即从可行集中排除第二个重载，因此当只需要第一个重载时，确定第二个重载的返回类型的问题永远不会出现。

（这是在默认模板参数中使用enable_if 来控制重载集的示例。）

Answer 2

你可以写一个对 SFINAE 友好的common_type——我个人认为特质几乎总是 SFINAE。也就是说：

// Black hole metafunction that eats everything
template<typename...> struct void_ { using type = void; };

template<typename... T>
using Void = typename void_<T...>::type;

// Due to std::common_type being variadic we need to
// pass a variadic pack around
template<typename... T> struct list {};

// Actually defined, but with no member types for SFINAE purposes
template<typename Sequence, typename Sfinae = void>
struct common_type_impl {};

template<typename... T>
struct common_type_impl<list<T...>, Void<typename std::common_type<T...>::type>>
: std::common_type<T...> {};

template<typename... T> struct common_type: common_type_impl<list<T...>> {};

现在，当 A<T> 和 U 之间没有公共类型时，将从候选列表中删除重载，而不是大声抱怨。

也可以完全替换std::common_type，因为它计算的结果有其自身的问题，如DR 2141 中所述。我不会概述替代方案，因为不清楚什么是更好的解决方案，特别是我认为 DR 的建议解决方案更差。