C++ concept for compound assignment operators - 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", i.e. 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, i.e. 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.