复合赋值运算符的 C++ 概念

Question

我有一个普通二元运算符的概念

template<typename Op, typename T> concept is_binary_operation =
    requires (const T& t1, const T& t2) // e.g. a+b
{
    {Op()(t1,t2)}->std::convertible_to<T>;
};

以及复合赋值运算符的概念

template<typename Op, typename T> concept is_operation_and_assign =
   requires (T& t1, const T& t2) // e.g a += b;
{
  {Op()(t1,t2)}->std::convertible_to<T>;
};

对于复合赋值运算符，这可以按预期工作：

template<typename T> struct op_and_assign
{
    T& operator()(T& t1, const T& t2)
    {
        t1 += t2;
        return t1;
    }
};

这个“is_operation_and_assign”而不是“is_binary_operation”

std::cout << is_binary_operation<op_and_assign<double>, double> << " ";
std::cout << is_operation_and_assign<op_and_assign<double>, double> << std::endl;

打印“0 1”。然而，std::plus 满足这两个概念：

std::cout << is_binary_operation<std::plus<double>, double> << " ";
std::cout << is_operation_and_assign<std::plus<double>, double> << std::endl;

打印“1 1”。

我必须如何更改“is_operation_and_assign”的概念，以便获得输出“1 0”，即它会由 op_and_assign 而不是由 std::plus 实现？

为了更清楚我需要什么：我有两个版本的算法，一个使用复合赋值运算符，一个使用二元运算符：

template<typename Op, typename T>
int f() requires is_operation_and_assign<Op, T>
{   
    return 0;
}
template<typename Op, typename T>
int f() requires is_binary_operation<Op, T>
{ 
    return 1;
}

我可以调用 op_and_assign 的版本

f<op_and_assign<double>, double>();

但 std::plus 的版本

f<std::plus<double>, double>();

不编译。 （错误：对“f”的调用不明确）

更新：同时我找到了解决方法：

当我简单地将&& !is_binary_operation<Op, T> 添加到第一个f 时：

template<typename Op, typename T>
int f() requires (is_operation_and_assign<Op, T>
               && !is_binary_operation<Op, T>)
{ 
    return 0;
}
template<typename Op, typename T>
int f()  requires is_binary_operation<Op, T> 
{ 
   return 1;
}

那么第二个调用就不再模棱两可了，即两者都

f<op_and_assign<double>, double>();
f<std::plus<double>, double>();

编译（并选择所需的函数）。

Answer 1

澄清你的概念实际上在检查什么很重要，因为它不是你想象的那样。

这个：

template<typename Op, typename T> concept is_operation_and_assign =
   requires (T& t1, const T& t2) // e.g a += b;
{
  {Op()(t1,t2)}->std::convertible_to<T>;
};

检查您是否可以使用T& 和T const& 调用Op()(t1, t2)，并且您得到满足convertible_to<T> 的内容。当您提供时：

template<typename T> struct op_and_assign
{
    T& operator()(T& t1, const T& t2)
    {
        t1 += t2;
        return t1;
    }
};

作为第一个模板参数，它实际上检查了什么？这是一个未计算的表达式，我们正在检查是否可以调用op_and_assign<T>()。我们没有评估呼叫操作员的主体，我们只是检查它是否是一个有效的呼叫。所以这和我们写的没什么不同：

template<typename T> struct op_and_assign
{
    T& operator()(T& t1, const T& t2);
};

它没有被评估，没有实体，所以唯一重要的是约束。这里没有约束，所以只要参数是可转换的，op_and_assign 总是可以调用的。

当你这样做时：

is_binary_operation<op_and_assign<double>, double>

您实际上是在询问是否可以适当地转换参数。对于is_binary_operation，您提供了两个double const& 类型的参数（来自您的require 表达式），但op_and_assign<double> 需要一个double&。这就是为什么此特定检查不起作用的原因。

---

关于如何修复它。 op_and_assign 应该看起来像这样：

struct op_and_assign
{
    template <typename T, typename U>
    auto operator()(T&& t, U&& u) const -> decltype(t += u);
};

现在我们实际上正在检查是否可以执行+=。

但这不会改变你不能分配给double const&。即使您没有进行您打算进行的检查，您也会在那里得到正确的答案。