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

Question

I have a concept for normal binary operators

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>;
};

and a concept for compound assignment operators

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>;
};

For compound assignment operators this works as expected:

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

This "is_operation_and_assign" but not "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;

prints "0 1". std::plus, however, satisfies both concepts:

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

prints "1 1".

How do I have to change the concept "is_operation_and_assign" so that I get the output "1 0", ie so that it will fulfilled by op_and_assign but not by std::plus?

To make more clear what I need: I have two versions of an algorithm, one using the compound assignment operator, one using the binary operator:

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;
}

I can call the version for op_and_assign

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

but the version for std::plus

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

does not compile. (error: call to 'f' is ambiguous)

Update : in the meanwhile I found a workaround:

When I simply add &&,is_binary_operation<Op, T> to the first 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;
}

then the second call is no longer ambiguous, ie both

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

compile (and choose the desired function).

Answer 1

It's important to clarify what actually your concept is checking, because it's not what you think it is.

This:

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>;
};

Checks that you can invoke Op()(t1, t2) with a T& and a T const& and that you get something that satisfies convertible_to<T> . When you provide:

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

as the first template parameter, what does that actually check? This is an unevaluated expression, we're checking to see if we can invoke op_and_assign<T>() . We're not evaluating the body of the call operator, we're just checking to see if it's a valid call. So it's no different than if we wrote:

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

It's unevaluated, there's no body, so the only things that matter are constraints. Here, there are no constraints, so op_and_assign is always invokable as long as the arguments are convertible.

When you do this:

is_binary_operation<op_and_assign<double>, double>

You're effectively asking if you can convert the arguments appropriately. For is_binary_operation , you're providing two arguments of type double const& (from your requires expression) but op_and_assign<double> needs to take one double& . That's why this particular check doesn't work.

---

For how to fix it. op_and_assign which should probably look something like this:

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

Now we're actually checking if we can perform += .

But that won't change that you can't assign to a double const& . You're getting the correct answer there, even if you weren't doing the check you intended to.