◐ Shell
clean mode source ↗

std::totally_ordered, std::totally_ordered_with — cppreference.com

Материал из cppreference.com

<tbody> </tbody>

Определено в заголовочном файле <concepts>

template<class T> concept totally_ordered = std::equality_comparable<T> && __PartiallyOrderedWith<T, T>;

 (1) (начиная с 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< const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>> && __PartiallyOrderedWith<T, U>;

 (2) (начиная с C++20)

template<class T, class U> concept __PartiallyOrderedWith = requires(const std::remove_reference_t<T>& t, const std::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) (только для пояснения*)

1) Концепт std::totally_ordered определяет, что операторы сравнения ==,!=,<,>,<=,>= для типа дают результаты, соответствующие строгому общему порядку типа.

2) Концепт std::totally_ordered_with определяет, что операторы сравнения ==,!=,<,>,<=,>= над (возможно, смешанными) операндами T и U дают результаты, соответствующие строгому общему порядку. Сравнение смешанных операндов даёт результаты, эквивалентные сравнению операндов, преобразованных к их общему типу.

3) Концепт только для описания __PartiallyOrderedWith определяет, что значение типа T и значение типа U можно сравнивать в частичном порядке с каждым другим (в любом порядке), используя <, >, <= и >=, и результаты сравнения согласуются.

Семантические требования

Эти концепты моделируются только в том случае, если они удовлетворены, и все концепты, которые они включают в себя, моделируются.

1) std::totally_ordered<T> моделируется, только если заданы значения lvalue a, b и c типа const std::remove_reference_t<T>:

  • Ровно одно из bool(a < b), bool(a > b) и bool(a == b) равно true;
  • Если bool(a < b) и bool(b < c) равны true, то bool(a < c) равно true;
  • 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> моделируется, только если дано

  • t и t2, значения lvalue обозначающие разные равные объекты типов const std::remove_reference_t<T> и std::remove_reference_t<T> соответственно и
  • u и u2, lvalue обозначающие разные равные объекты типов const std::remove_reference_t<U> и std::remove_reference_t<U> соответственно,

пусть C будет std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>, и, учитывая выражение E и тип C, пусть CONVERT_TO<C>(E) будет:

  • static_cast<C>(std::as_const(E)).
 (до C++23)
  • static_cast<const C&>(std::as_const(E)), если это допустимое выражение,
  • static_cast<const C&>(std::move(E)) иначе.
 (начиная с C++23)

верно следующее:

  • 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> моделируется, только если дано

  • любое lvalue t типа const std::remove_reference_t<T>, и
  • любое lvalue u типа const std::remove_reference_t<U>,

верно следующее:

  • t < u, t <= u, t > u, t >= u, u < t, u <= t, u > t и u >= t имеют тот же домен;
  • bool(t < u) == bool(u > t);
  • bool(u < t) == bool(t > u);
  • bool(t <= u) == bool(u >= t); и
  • bool(u <= t) == bool(t >= u).

Сохранение равенства

Выражения, объявленные в выражениях requires концептов стандартной библиотеки, должны сохранять равенство (если не указано иное).

Варианты неявных выражений

Выражение requires, которое использует выражение, которое не модифицирует для некоторого константного операнда lvalue, также неявно требует дополнительных вариаций этого выражения, которые принимают неконстантное lvalue или (возможно, константное) rvalue для данного операнда, если только такое изменение выражения явно требуется с различной семантикой. Эти вариации неявных выражений должны соответствовать тем же семантическим требованиям, что и объявленное выражение. Степень, в которой реализация проверяет синтаксис вариантов, не определена.

Смотрите также