Difference between revisions of "cpp/concepts/common with"
m (→See also: P1754R1) |
(+References) |
||
| (3 intermediate revisions by 3 users not shown) | |||
| Line 1: | Line 1: | ||
| − | {{cpp/title|common_with}} | + | {{cpp/title|common_with {{mark since c++20}}}} |
{{cpp/concepts/navbar}} | {{cpp/concepts/navbar}} | ||
{{ddcl|header=concepts|since=c++20|1= | {{ddcl|header=concepts|since=c++20|1= | ||
| − | template <class T, class U> | + | template< class T, class U > |
concept common_with = | concept common_with = | ||
| − | + | std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>> && | |
| − | + | requires { | |
| − | + | static_cast<std::common_type_t<T, U>>(std::declval<T>()); | |
| − | + | static_cast<std::common_type_t<T, U>>(std::declval<U>()); | |
| − | + | } && | |
| − | + | std::common_reference_with< | |
| − | + | std::add_lvalue_reference_t<const T>, | |
| − | + | std::add_lvalue_reference_t<const U>> && | |
| − | + | std::common_reference_with< | |
| − | + | std::add_lvalue_reference_t<std::common_type_t<T, U>>, | |
| − | + | std::common_reference_t< | |
| − | + | std::add_lvalue_reference_t<const T>, | |
| − | + | std::add_lvalue_reference_t<const U>>>; | |
}} | }} | ||
The concept {{tt|common_with<T, U>}} specifies that two types {{tt|T}} and {{tt|U}} share a ''common type'' (as computed by {{lc|std::common_type_t}}) to which both can be converted. | The concept {{tt|common_with<T, U>}} specifies that two types {{tt|T}} and {{tt|U}} share a ''common type'' (as computed by {{lc|std::common_type_t}}) to which both can be converted. | ||
| − | === Semantic requirements === | + | ===Semantic requirements=== |
| − | T and U model {{ | + | T and U model {{co|std::common_with<T, U>}} only if, given [[cpp/concepts#Equality preservation|equality-preserving]] expressions {{tt|t1}}, {{tt|t2}}, {{tt|u1}} and {{tt|u2}} such that {{c|decltype((t1))}} and {{c|decltype((t2))}} are both {{tt|T}} and {{c|decltype((u1))}} and {{c|decltype((u2))}} are both {{tt|U}}, |
* {{c|std::common_type_t<T, U>(t1)}} equals {{c|std::common_type_t<T, U>(t2)}} if and only if {{tt|t1}} equals {{tt|t2}}; and | * {{c|std::common_type_t<T, U>(t1)}} equals {{c|std::common_type_t<T, U>(t2)}} if and only if {{tt|t1}} equals {{tt|t2}}; and | ||
* {{c|std::common_type_t<T, U>(u1)}} equals {{c|std::common_type_t<T, U>(u2)}} if and only if {{tt|u1}} equals {{tt|u2}}. | * {{c|std::common_type_t<T, U>(u1)}} equals {{c|std::common_type_t<T, U>(u2)}} if and only if {{tt|u1}} equals {{tt|u2}}. | ||
| − | In other words, the conversion to the common type must preserve equality. | + | In other words, the conversion to the common type must [[cpp/concepts#Equality preservation|preserve equality]]. |
{{cpp/concepts/equality preservation|skip-requires=yes}} | {{cpp/concepts/equality preservation|skip-requires=yes}} | ||
| − | === See also === | + | ===References=== |
| + | {{ref std c++23}} | ||
| + | {{ref std|section=18.4.6|title=Concept {{tt|common_with}}|id=concept.common}} | ||
| + | {{ref std end}} | ||
| + | {{ref std c++20}} | ||
| + | {{ref std|section=18.4.6|title=Concept {{tt|common_with}}|id=concept.common}} | ||
| + | {{ref std end}} | ||
| + | |||
| + | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
{{dsc inc|cpp/types/dsc common_type}} | {{dsc inc|cpp/types/dsc common_type}} | ||
Latest revision as of 10:01, 7 September 2024
| Defined in header <concepts>
|
||
| template< class T, class U > concept common_with = |
(since C++20) | |
The concept common_with<T, U> specifies that two types T and U share a common type (as computed by std::common_type_t) to which both can be converted.
Contents |
[edit] Semantic requirements
T and U model std::common_with<T, U> only if, given equality-preserving expressions t1, t2, u1 and u2 such that decltype((t1)) and decltype((t2)) are both T and decltype((u1)) and decltype((u2)) are both U,
- std::common_type_t<T, U>(t1) equals std::common_type_t<T, U>(t2) if and only if
t1equalst2; and - std::common_type_t<T, U>(u1) equals std::common_type_t<T, U>(u2) if and only if
u1equalsu2.
In other words, the conversion to the common type must preserve equality.
[edit] Equality preservation
Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).
[edit] References
- C++23 standard (ISO/IEC 14882:2024):
- 18.4.6 Concept
common_with[concept.common]
- 18.4.6 Concept
- C++20 standard (ISO/IEC 14882:2020):
- 18.4.6 Concept
common_with[concept.common]
- 18.4.6 Concept
[edit] See also
| (C++11) |
determines the common type of a group of types (class template) |
| determines the common reference type of a group of types (class template) | |
| (C++20) |
specifies that two types share a common reference type (concept) |
