From Jason Turner

[cmp.strongord]

C++20 → C++23 1.7 KB 15 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game
C++ Weekly: Ep 175

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpj_e1srhg/{from.md → to.md} +5 -6
tmp/tmpj_e1srhg/{from.md → to.md} RENAMED
@@ -1,19 +1,18 @@
1
  #### Class `strong_ordering` <a id="cmp.strongord">[[cmp.strongord]]</a>
2
 
3
  The `strong_ordering` type is typically used as the result type of a
4
- three-way comparison operator [[expr.spaceship]] that (a) admits all of
5
- the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), and
6
- (b) does imply substitutability.
7
 
8
  ``` cpp
9
  namespace std {
10
  class strong_ordering {
11
  int value; // exposition only
12
 
13
  // exposition-only constructors
14
- constexpr explicit strong_ordering(eq v) noexcept : value(int(v)) {} // exposition only
15
  constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {} // exposition only
16
 
17
  public:
18
  // valid values
19
  static const strong_ordering less;
@@ -40,12 +39,12 @@ namespace std {
40
  friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
41
  };
42
 
43
  // valid values' definitions
44
  inline constexpr strong_ordering strong_ordering::less(ord::less);
45
- inline constexpr strong_ordering strong_ordering::equal(eq::equal);
46
- inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent);
47
  inline constexpr strong_ordering strong_ordering::greater(ord::greater);
48
  }
49
  ```
50
 
51
  ``` cpp
 
1
  #### Class `strong_ordering` <a id="cmp.strongord">[[cmp.strongord]]</a>
2
 
3
  The `strong_ordering` type is typically used as the result type of a
4
+ three-way comparison operator [[expr.spaceship]] for a type that admits
5
+ all of the six two-way comparison operators [[expr.rel]], [[expr.eq]]
6
+ and for which equality does imply substitutability.
7
 
8
  ``` cpp
9
  namespace std {
10
  class strong_ordering {
11
  int value; // exposition only
12
 
13
  // exposition-only constructors
 
14
  constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {} // exposition only
15
 
16
  public:
17
  // valid values
18
  static const strong_ordering less;
 
39
  friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
40
  };
41
 
42
  // valid values' definitions
43
  inline constexpr strong_ordering strong_ordering::less(ord::less);
44
+ inline constexpr strong_ordering strong_ordering::equal(ord::equal);
45
+ inline constexpr strong_ordering strong_ordering::equivalent(ord::equivalent);
46
  inline constexpr strong_ordering strong_ordering::greater(ord::greater);
47
  }
48
  ```
49
 
50
  ``` cpp