Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::totally_ordered,std::totally_ordered_with

      From cppreference.com
      <cpp‎ |concepts
       
       
      Concepts library
       
      Defined in header<concepts>
      template<class T>

      concept totally_ordered=

         std::equality_comparable<T>&& __PartiallyOrderedWith<T, T>;
      		 (1)(since C++20)
      template<class T,class U>

      concept totally_ordered_with=
          std::totally_ordered<T>&&
          std::totally_ordered<U>&&
         std::equality_comparable_with<T, U>&&
          std::totally_ordered<
             std::common_reference_t<
                 conststd::remove_reference_t<T>&,
                 conststd::remove_reference_t<U>&>>&&

          __PartiallyOrderedWith<T, U>;
      		 (2)(since C++20)
      Helper concepts
      template<class T,class U>

      concept __PartiallyOrderedWith=
          requires(conststd::remove_reference_t<T>& t,
                   conststd::remove_reference_t<U>& u){
             { t<  u}->boolean-testable;
             { t>  u}->boolean-testable;
             { t<= u}->boolean-testable;
             { t>= u}->boolean-testable;
             { u<  t}->boolean-testable;
             { u>  t}->boolean-testable;
             { u<= t}->boolean-testable;
             { u>= t}->boolean-testable;

         };
      		 (3)(exposition only*)
      1) The conceptstd::totally_ordered specifies that the comparison operators==,!=,<,>,<=,>= on a type yield results consistent with astrict total order on the type.
      2) The conceptstd::totally_ordered_with specifies that the comparison operators==,!=,<,>,<=,>= on (possibly mixed)T andU operands yield results consistent with a strict total order. Comparing mixed operands yields results equivalent to comparing the operands converted to their common type.
      3) The exposition-only concept__PartiallyOrderedWith specifies that a value of typeT and a value of typeU can be compared in a partial order with each other (in either order) using<,>,<=, and>=, and the results of the comparisons are consistent.

      Contents

      [edit]Semantic requirements

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

      1)std::totally_ordered<T> is modeled only if, given lvaluesa,b andc of typeconststd::remove_reference_t<T>:
      • Exactly one ofbool(a< b),bool(a> b) andbool(a== b) istrue;
      • Ifbool(a< b) andbool(b< c) are bothtrue, thenbool(a< c) istrue;
      • bool(a> b)==bool(b< a)
      • bool(a>= b)==!bool(a< b)
      • bool(a<= b)==!bool(b< a)
      2)std::totally_ordered_with<T, U> is modeled only if, given

      letC bestd::common_reference_t<conststd::remove_reference_t<T>&,conststd::remove_reference_t<U>&>, and, given an expressionE and a typeC, letCONVERT_TO<C>(E) be:

      (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)

      the following are true:

      • bool(t< u)==bool(CONVERT_TO<C>(t2)< CONVERT_TO<C>(u2))
      • bool(t> u)==bool(CONVERT_TO<C>(t2)> CONVERT_TO<C>(u2))
      • bool(t<= u)==bool(CONVERT_TO<C>(t2)<= CONVERT_TO<C>(u2))
      • bool(t>= u)==bool(CONVERT_TO<C>(t2)>= CONVERT_TO<C>(u2))
      • bool(u< t)==bool(CONVERT_TO<C>(u2)< CONVERT_TO<C>(t2))
      • bool(u> t)==bool(CONVERT_TO<C>(u2)> CONVERT_TO<C>(t2))
      • bool(u<= t)==bool(CONVERT_TO<C>(u2)<= CONVERT_TO<C>(t2))
      • bool(u>= t)==bool(CONVERT_TO<C>(u2)>= CONVERT_TO<C>(t2))
      3)__PartiallyOrderedWith<T, U> is modeled only if given

      the following are true:

      • t< u,t<= u,t> u,t>= u,u< t,u<= t,u> t, andu>= t have the same domain;
      • bool(t< u)==bool(u> t);
      • bool(u< t)==bool(t> u);
      • bool(t<= u)==bool(u>= t); and
      • bool(u<= t)==bool(t>= u).

      [edit]Equality preservation

      Expressions declared inrequires expressions of the standard library concepts are required to beequality-preserving (except where stated otherwise).

      [edit]Implicit expression variations

      Arequires expression that uses an expression that is non-modifying for some constant lvalue operand also requiresimplicit expression variations.

      [edit]References

      • C++23 standard (ISO/IEC 14882:2024):
      • 18.5.5 Concepttotally_ordered [concept.totallyordered]
      • C++20 standard (ISO/IEC 14882:2020):
      • 18.5.4 Concepttotally_ordered [concept.totallyordered]

      [edit]See also

      specifies that operator<=> produces consistent result on given types
      (concept)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/concepts/totally_ordered&oldid=177895"
      [8]ページ先頭
      ©2009-2025 Movatter.jp