1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
// { dg-do compile { target c++26 } }
#include <functional>
#ifndef __cpp_lib_reference_wrapper
# error "Feature-test macro for reference_wrapper missing"
#elif __cpp_lib_reference_wrapper != 202403
# error "Feature-test macro for reference_wrapper has wrong value"
#endif
// P2944R3 Comparisons for reference_wrapper
auto check(int i, std::reference_wrapper<int> r) -> bool {
return i == r;
}
template <class T> using Ref = std::reference_wrapper<T>;
template <class T>
concept ref_equality_comparable
= requires (T a, T const ca, Ref<T> r, Ref<T const> cr) {
// the usual T is equality-comparable with itself
a == a;
a == ca;
ca == ca;
// Ref<T> is equality-comparable with itself
r == r;
r == cr;
cr == cr;
// T and Ref<T> are equality-comparable
a == r;
a == cr;
ca == r;
ca == cr;
};
static_assert( ref_equality_comparable<int> );
struct A {
auto operator==(A const&) const -> bool { return true; }
};
struct B {
friend auto operator==(B const&, B const&) -> bool { return true; }
};
template <class T>
struct C {
friend auto operator==(C const&, C const&) -> bool { return true; }
};
template <class T>
struct D { };
template <class T>
auto operator==(D<T> const&, D<T> const&) -> bool { return true; }
static_assert(ref_equality_comparable<int>);
static_assert(ref_equality_comparable<A>);
static_assert(ref_equality_comparable<B>);
static_assert(ref_equality_comparable<C<int>>);
static_assert(ref_equality_comparable<D<int>>);
#include <string_view>
static_assert(ref_equality_comparable<std::string_view>);
template <typename T>
struct ValArray {
friend auto operator==(ValArray const&, ValArray const&) -> ValArray<bool> {
return {};
}
};
void f(ValArray<int> v) {
// this is valid and has type ValArray<bool>
v == v;
// this is also valid today and has the same type
std::ref(v) == std::ref(v);
}
struct ComparesAsInt {
friend auto operator==(ComparesAsInt, ComparesAsInt) -> int;
};
auto f(std::reference_wrapper<ComparesAsInt> a,
std::reference_wrapper<ComparesAsInt> b) {
// today: compiles and returns int
// proposed: compiles and returns bool
return a == b;
}
ComparesAsInt& c();
static_assert( std::is_same_v<decltype(f(c(), c())), bool> );
|
