RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/algorithm/../iterator/../concepts/equality_comparable.html below:

std::equality_comparable, std::equality_comparable_with - cppreference.com

template< class T > concept equality_comparable = __WeaklyEqualityComparableWith<T, T>;

(1) (since C++20) (2) (since C++20)

Helper concepts

(3) (exposition only*) (4) (until C++23)
(exposition only*) template< class T, class U, class C = std::common_reference_t<const T&, const U&> > concept _ComparisonCommonTypeWithImpl = std::same_as<std::common_reference_t<const T&, const U&>, std::common_reference_t<const U&, const T&>> && requires { requires std::convertible_to<const T&, const C&> || std::convertible_to<T, const C&>; requires std::convertible_to<const U&, const C&> || std::convertible_to<U, const C&>; }; template< class T, class U > concept __ComparisonCommonTypeWith = _ComparisonCommonTypeWithImpl<std::remove_cvref_t<T>, std::remove_cvref_t<U>>; (since C++23)
(exposition only*)

1) The concept std::equality_comparable specifies that the comparison operators == and != on T reflects equality: == yields true if and only if the operands are equal.

2) The concept std::equality_comparable_with specifies that the comparison operators == and != on (possibly mixed) T and U operands yield results consistent with equality. Comparing mixed operands yields results equivalent to comparing the operands converted to their common type.

3) The exposition-only concept __WeaklyEqualityComparableWith specifies that an object of type T and an object of type U can be compared for equality with each other (in either order) using both == and !=, and the results of the comparisons are consistent.

4) The exposition-only concept __ComparisonCommonTypeWith specifies that two types share a common type, and a const lvalue or a non-const rvalue(since C++23) of either type is convertible to that common type.

[edit] Semantic requirements

These concepts are modeled only if they are satisfied and all concepts they subsume are modeled.

In the following paragraphs, given an expression E and a type C, CONVERT_TO<C>(E) is defined as:

static_cast<C>(std::as_const(E)).

(until C++23)

static_cast<const C&>(std::as_const(E)) if that is a valid expression,
static_cast<const C&>(std::move(E)) otherwise.

(since C++23) 1) std::equality_comparable<T>

is modeled only if, given objects

a

and

b

of type

T

bool(a == b)

true

if and only if

a

and

b

are equal. Together with the requirement that

a == b

equality-preserving

, this implies that

==

is symmetric and transitive, and further that

==

is reflexive for all objects

a

that are equal to at least one other object.

3) __WeaklyEqualityComparableWith<T, U>

is modeled only if given

t, an lvalue of type const std::remove_reference_t<T> and
u, an lvalue of type const std::remove_reference_t<U>,

the following are true:

t == u, u == t, t != u, u != t have the same domain;
bool(u == t) == bool(t == u);
bool(t != u) == !bool(t == u); and
bool(u != t) == bool(t != u).

4) __WeaklyEqualityComparableWith<T, U>

is modeled only if:

[edit] Equality preservation

Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).

[edit] Implicit expression variations

A requires expression that uses an expression that is non-modifying for some constant lvalue operand also requires implicit expression variations.

[edit] References

C++23 standard (ISO/IEC 14882:2024):

18.5.4 Concept equality_comparable [concept.equalitycomparable]

C++20 standard (ISO/IEC 14882:2020):

18.5.3 Concept equality_comparable [concept.equalitycomparable]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4