std::strong_equality

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Library feature-test macros
Date and time
Function objects
Formatting library (C++20)
initializer_list (C++11)
source_location (C++20)
bitset
hash (C++11)
integer_sequence (C++14)
Relational operators (deprecated in C++20)
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Comparisons (C++20)
three_way_comparablethree_way_comparable_with
strong_ordering weak_ordering partial_ordering strong_equality weak_equality common_comparison_category compare_three_way_result	strong_order weak_order partial_order compare_strong_order_fallback compare_weak_order_fallback compare_partial_order_fallback compare_three_way	is_eqis_neqis_ltis_lteqis_gtis_gteq
Common vocabulary types
pair tuple (C++11) apply (C++17) make_from_tuple (C++17)	optional (C++17) any (C++17) variant (C++17)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)
launder (C++17)

 

Defined in header <compare>
class strong_equality;		(since C++20)

The class type std::strong_equality is the result type of a three-way comparison that

• admits only equality and inequality comparisons (no less-than/greater-than)

• implies substitutability: if a is equivalent to b, f(a) is also equivalent to f(b), where f denotes a function that reads only comparison-salient state that is accessible via the argument's public const members. In other words, equivalent values are indistinguishable.

Constants

The type std::strong_equality has four valid values, implemented as const static data members of its type:

Member constant	Definition
equivalent(inline constexpr) [static]	a valid value of the type std::strong_equality indicating equality, equal to equal (public static member constant)
equal(inline constexpr) [static]	a valid value of the type std::strong_equality indicating equality, equal to equivalent (public static member constant)
nonequivalent(inline constexpr) [static]	a valid value of the type std::strong_equality indicating non-equality, equal to nonequal (public static member constant)
nonequal(inline constexpr) [static]	a valid value of the type std::strong_equality indicating non-equality, equal to nonequivalent (public static member constant)

Conversions

std::strong_equality is implicitly-convertible to std::weak_equality, and std::strong_ordering is implicitly-convertible to strong_equality.

operator weak_equality

implicit conversion to std::weak_equality (public member function)

std::strong_equality::operator weak_equality

constexpr operator weak_equality() const noexcept;

Return value

std::weak_equality::equivalent if v is equivalent or equal, std::weak_equality::nonequivalent if v is nonequivalent or nonequal.

Comparisons

Comparison operators are defined between values of this type and literal ​0​. This supports the expressions a <=> b == 0 and a <=> b != 0 used to convert the result of a three-way comparison operator to a boolean relationship; see std::is_eq and std::is_neq.

The behavior of a program that attempts to compare a strong_equality with anything other than the integer literal ​0​ is undefined.

operator==operator<=>

compares with zero or a strong_equality (function)

operator==

friend constexpr bool operator==(strong_equality v, /*unspecified*/ u) noexcept;	(1)
friend constexpr bool operator==(strong_equality v, strong_equality w) noexcept = default;	(2)

Parameters

v, w	-	std::strong_equality values to check
u	-	an unused parameter of any type that accepts literal zero argument

Return value

1) true if v is equivalent or equal, false if v is nonequivalent or nonequal

2) true if both parameters hold the same value, false otherwise. Notes that equal is equal to equivalent and nonequal is equal to nonequivalent, but equal is not equal to nonequal.

operator<=>

friend constexpr strong_equality operator<=>(strong_equality v, /*unspecified*/ u) noexcept; friend constexpr strong_equality operator<=>(/*unspecified*/ u, strong_equality v) noexcept;

Parameters

v	-	a std::strong_equality value to check
u	-	an unused parameter of any type that accepts literal zero argument

Return value

v

See also

strong_ordering (C++20)	the result type of 3-way comparison that supports all 6 operators and is substitutable (class)
weak_ordering (C++20)	the result type of 3-way comparison that supports all 6 operators and is not substitutable (class)
partial_ordering (C++20)	the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values (class)
weak_equality (C++20)	the result type of 3-way comparison that supports only equality/inequality and is not substitutable (class)