如何使用 SFINAE 来防止模板函数变窄？

Question

我正在尝试为 Vector 类实现基本算术运算，并希望支持混合基础类型，同时防止发生缩小。

template <typename T1,typename T2>
Vector<T1> operator+( Vector<T1> lhs, const Vector<T2>& rhs, std::enable_if< ! is_narrowing_conversion<T2,T1>::value >::type* = nullptr )
{ return lhs += rhs; }

我想实现 is_narrowing_conversion 以便仅在类型不缩小时才允许转换。以下是一些示例：

Vector<double> a = Vector<double>() + Vector<float>(); //OK
Vector<float> a = Vector<float> + Vector<double>; //Fails to find the operator+ function

最后，我想编写第二个模板 operator+ 函数，该函数将通过返回一个 Vector 来处理相反的情况。

我发现这篇文章with an incomplete example。但这还不够，因为他指出它不允许 uint8_t 到 uint64_t 转换。

我还发现了Daniel Krügler's paper on fixing is_constructible。特别是在这篇论文中，他提到了使用列表初始化，它已经具有窄化语义，但我不确定如何将他提到的内容转换为可用于 SFINAE 模板推导的适当特征。

Answer 1

通过std::common_type 使用 SFINAE 怎么样？

下面是一个简化的例子（不是Vector，而是简单的值；不是operator+()，而是sum()函数），但我希望你能明白我的意思

#include <iostream>
#include <type_traits>


template <typename T1, typename T2>
T1 sum (T1 t1,
        T2 const & t2,
        typename std::enable_if<std::is_same<
              T1,
              typename std::common_type<T1, T2>::type
           >::value>::type * = nullptr)
 { return t1 += t2; }

int main()
 {
   float  a      = 1.1f;
   double b      = 2.2;
   long double c = 3.3;

   std::cout << sum(b, a) << std::endl;
   std::cout << sum(c, a) << std::endl;
   std::cout << sum(c, b) << std::endl;
   // std::cout << sum(a, b) << std::endl; compilation error
   // std::cout << sum(a, c) << std::endl; compilation error
   // std::cout << sum(b, c) << std::endl; compilation error
 }

Answer 2

对Vector 有一些假设，但你应该明白：

template <typename T1,typename T2>
Vector<typename std::common_type<T1, T2>::type> 
    operator+(Vector<T1> const& lhs, Vector<T2> const& rhs)
{ 
    std::size_t const n = std::min(lhs.size(), rhs.size());
    Vector<typename std::common_type<T1, T2>::type> res(n);
    for(std::size_t i{}; i < n; ++i) res[i] = a[i] + b[i];
    return res; 
}

Vector<double> a = Vector<double>() + Vector<float>(); // OK
Vector<double> b = Vector<float>() + Vector<double>(); // OK

Answer 3

您可以使用{} 构造函数，让它为您检测narrowing conversions。
你可以这样做：

template<typename T>
struct Vector {
    T value;
};

template <typename T1, typename T2>
auto operator+(Vector<T1>, const Vector<T2>& rhs)
-> decltype(T1{rhs.value}, Vector<T1>{})
{ return {}; }

int main() {
    auto a = Vector<double>{} + Vector<float>{};
    //auto b = Vector<float>{} + Vector<double>{};
    (void)a;
}

也就是说，对于涉及尾随返回类型的 sfinae 表达式，您可以使用通常的形式。
如果您的 Vector 类模板没有默认构造函数，您仍然可以使用 std::declval 解决它：

-> decltype(T1{rhs.value}, std::declval<Vector<T1>>())

请注意，由于[dcl.init.list]/7.2 和后面的其他项目符号，您不能简单地在上面的代码中执行此操作：

-> decltype(T1{T2{}}, Vector<T1>{})

否则，在您的具体示例中，以下内容将是有效的：

auto b = Vector<float>{} + Vector<double>{};

因此，您必须使用与 rhs 一起提供的实际值，并且（让我说）测试它 使用用于专门化 lhs 的实际类型。
只要包含的值是可访问的（它是有效的或者操作员是您班级的朋友），这应该不是问题。

---

附带说明，您无法通过仅使用 T1 和 T2 类型正确定义在您的情况下正常工作的 is_narrowing_conversion。
例如，考虑[dcl.init.list]/7.2（强调我的）和您提出的测试代码：

[...] 或者从double到float，除非源是常量表达式并且转换后的实际值在可以表示的值范围内（即使不能准确表示） [...]

因为您没有用于测试的实际值，您所能做的就是尝试像T1{T2{}} 这样的东西。无论如何，这是行不通的。换句话说，由于上面提到的项目符号，float{double{}} 将被正确接受。
类似的情况也适用于少数其他类型。

---

另一种有效的方法是使用std::common_type。
无论如何，已经有一个pretty good answer 提出了它。不值得再重复一遍示例代码。