Просмотр кода страницы cpp/language/default comparisons

У вас нет прав на выполнение действия «редактирование этой страницы» по следующей причине:
Запрошенное действие могут выполнять участники одной из следующих групп: Участники, Администраторы.
Вы можете просмотреть и скопировать исходный код этой страницы.
{{title|Сравнение по умолчанию {{mark since c++20}}}}
{{cpp/language/expressions/navbar}}

Предоставляет способ запросить у компилятора создание согласованных операторов сравнения для класса.

===Синтаксис===
{{sdsc begin}}
{{sdsc|num=1|{{spar sep|возвращаемый-тип имя-класса}}{{ttb|1=::operator}}{{spar|оп}}<br>{{nbsp|4}}{{ttb|(}}{{c/core|const}} {{spar sep|имя-класса}}{{tt|&}}{{ttb|) const &}}{{mark optional}} {{ttb|1== default;}}|notes={{mark since c++20}}}}
{{sdsc|num=2|{{ttb|friend}} {{spar|возвращаемый-тип}} {{ttb|1=operator}}{{spar sep|оп}}{{ttb|(}}{{c/core|const}} {{spar sep|имя-класса}}{{tt|&}}{{ttb|,}} {{c/core|const}} {{spar sep|имя-класса}}{{tt|&}}{{ttb|1=) = default;}}|notes={{mark since c++20}}}}
{{sdsc|num=3|{{ttb|friend}} {{spar|возвращаемый-тип}} {{ttb|1=operator}}{{spar sep|оп}}{{ttb|(}}{{spar sep|имя-класса}}{{ttb|,}} {{spar sep|имя-класса}}{{ttb|1=) = default;}}|notes={{mark since c++20}}}}
{{sdsc|num=4|{{spar sep|возвращаемый-тип имя-класса}}{{ttb|1=::operator}}{{spar|оп}}<br>{{nbsp|4}}{{ttb|(}}{{c/core|this const}} {{spar sep|имя-класса}}{{tt|&}}{{ttb|,}} {{c/core|const}} {{spar sep|имя-класса}}{{tt|&}}{{ttb|1=) = default;}}|notes={{mark since c++23}}}}
{{sdsc|num=5|{{spar sep|возвращаемый-тип имя-класса}}{{ttb|1=::operator}}{{spar sep|оп}}{{ttb|(}}{{c/core|this}} {{spar sep|имя-класса}}{{ttb|,}} {{spar sep|имя-класса}}{{ttb|1=) = default;}}|notes={{mark since c++23}}}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|оп}} | оператор сравнения ({{tt|1=<=>}}, {{tt|1===}}, {{tt|1=!=}}, {{tt|<}}, {{tt|>}}, {{tt|1=<=}} или {{tt|1=>=}})  }}
{{par | {{spar|возвращаемый-тип}} | возвращаемый тип операторной функции. Должен быть
* {{rlpt|auto}} или одним из [[#Пользовательские сравнения и категории сравнения|трёх типов категорий сравнения]], если {{spar|оп}} равно {{ttb|1=<=>}},
* иначе, {{c/core|bool}}}}
{{par end}}

===Объяснение===
@1@ Объявляет функцию сравнения по умолчанию как функцию-элемент.
@2@ Объявляет функцию сравнения по умолчанию как функцию, не являющуюся элементом.
@3@ Объявляет функцию сравнения по умолчанию как функцию, не являющуюся элементом. Аргументы передаются по значению.

Функция трёхстороннего сравнения (независимо от того, используется она по умолчанию или нет) вызывается всякий раз, когда значения сравниваются с использованием {{tt|<}}, {{tt|>}}, {{tt|1=<=}}, {{tt|1=>=}} или {{tt|1=<=>}} и разрешение перегрузки выбирает эту перегрузку.

Функция сравнения на равенство (независимо от того, используется она по умолчанию или нет) вызывается всякий раз, когда значения сравниваются с использованием {{tt|1===}} или {{tt|1=!=}}, и разрешение перегрузки выбирает эту перегрузку.

Как и специальные функции-элементы по умолчанию, функция сравнения по умолчанию определяется, если {{rlp|definition#Использование ODR|используется odr}} или {{rlp|constant expression#Функции и переменные, необходимые для константной оценки|она необходима для константной оценки}}.

{{todo|упомянуть специальное правило разрешения перегрузки для операторов сравнения, добавленное в C++20}}

===Сравнение по умолчанию===

====Трёхстороннее сравнение по умолчанию====
{{c/core|1=operator<=>}} по умолчанию выполняет лексикографическое сравнение, последовательно сравнивая базовые (слева направо в глубину), а затем нестатические объекты элементы (в порядке объявления) {{tt|T}} для вычисления {{tt|1=<=>}}, рекурсивно расширяя элементы массива (в порядке возрастания индекса) и преждевременно останавливаясь при обнаружении неравного результата, то есть:
{{source|1=
for /*каждый базовый объект или подобъект элемент o T*/
   if (auto cmp = static_cast<R>(compare(lhs.o, rhs.o)); cmp != 0)
      return cmp;
return static_cast<R>(strong_ordering::equal);
}}

Не указано, сравниваются ли виртуальные базовые подобъекты более одного раза.

Если объявлен тип возвращаемого значения {{c/core|auto}}, то фактический тип возвращаемого значения является общей категорией сравнения базового подобъекта и подобъекта-элемента, а также элементов массивов-элементов для сравнения (смотрите {{ltt std|cpp/utility/compare/common_comparison_category}}). Это упрощает написание случаев, когда возвращаемый тип нетривиально зависит от элементов, например:
{{source|1=
template<class T1, class T2>
struct P {
  T1 x1;
  T2 x2;
  friend auto operator<=>(const P&, const P&) = default;
};
}}

Пусть {{tt|R}} возвращаемый тип, каждая пара подобъектов {{c|a}}, {{c|b}} сравнивается следующим образом:

* Если {{c|1=a <=> b}} используется и может быть явно преобразовано в {{tt|R}} с помощью {{rlpt|static_cast}}{{mark unreviewed dr|cwg|2539}}, результатом сравнения является {{c|1=static_cast<R>(a <=> b)}}.
* Иначе, если выполняется разрешение перегрузки для {{c|1=a <=> b}} и обнаруживается хотя бы один жизнеспособный кандидат, сравнение не определяется ({{c/core|1=operator<=>}} определён как удалённый).
* Иначе, если {{tt|R}} не является типом категории сравнения (смотрите ниже), либо {{c|1=a == b}} или {{c|a < b}} не используются, сравнение не определено ({{c/core|1=operator<=>}} определяется как удалённый).
* Иначе, если {{tt|R}} является {{ltt std|cpp/utility/compare/strong_ordering}}, результатом будет
{{source|1=
a == b ? R::equal :
a < b  ? R::less :
         R::greater
}}
* Иначе, если {{tt|R}} является {{ltt std|cpp/utility/compare/weak_ordering}}, результатом будет
{{source|1=
a == b ? R::equivalent :
a < b  ? R::less :
         R::greater
}}
* Иначе ({{tt|R}} является {{ltt std|cpp/utility/compare/partial_ordering}}), результатом будет
{{source|1=
a == b ? R::equivalent :
a < b  ? R::less :
b < a  ? R::greater : 
         R::unordered
}}

Согласно правилам для любой перегрузки {{c/core|1=operator<=>}}, перегрузка {{tt|1=<=>}} по умолчанию также позволяет сравнивать тип с {{tt|1=<}}, {{tt|1=<=}}, {{tt|1= >}} и {{tt|1= >=}}.

Если {{c/core|1=operator<=>}} используется по умолчанию, а {{c/core|1=operator==}} вообще не объявлен, то {{c/core|1=operator==}} неявно используется по умолчанию.

{{example|code=
#include <compare>
#include <iostream>
#include <set>

struct Point
{
  int x;
  int y;
  auto operator<=>(const Point&) const = default;
  // ... функции несравнения ...
};
// компилятор генерирует все шесть операторов двустороннего сравнения

int main()
{
  Point pt1{1, 1}, pt2{1, 2};
  std::set<Point> s; // OK
  s.insert(pt1);     // OK
  std::cout << std::boolalpha
    << (pt1 == pt2) << ' ' // false; operator== неявно используется по умолчанию.
    << (pt1 != pt2) << ' ' // true
    << (pt1 <  pt2) << ' ' // true
    << (pt1 <= pt2) << ' ' // true
    << (pt1 >  pt2) << ' ' // false
    << (pt1 >= pt2) << ' ';// false
}
}}

====Сравнение на равенство по умолчанию====
Класс может определить {{c/core|1=operator==}} как значение по умолчанию с возвращаемым значением {{c/core|bool}}. Это создаст сравнение на равенство каждого базового класса и подобъекта-элемента в порядке их объявления. Два объекта равны, если равны значения их базовых классов и элементов. Тест будет коротким замыканием, если неравенство обнаружется в элементах или базовых классах ранее в порядке объявления.

Согласно правилам для {{c/core|1=operator==}}, это также позволит проверить на неравенство:

{{example|code=
#include <iostream>

struct Point
{
  int x;
  int y;
  bool operator==(const Point&) const = default;
  // ... функции несравнения ...
};
// компилятор генерирует поэлементную проверку на равенство

int main()
{
  Point pt1{3, 5}, pt2{2, 5};
  std::cout << std::boolalpha
    << (pt1 != pt2) << '\n'  // true
    << (pt1 == pt1) << '\n'; // true
  struct [[maybe_unused]] { int x{}, y{}; } p, q;
  // if (p == q) { } // Ошибка: 'operator==' не определён
}
}}

====Другие операторы сравнения по умолчанию====
Любой из четырёх операторов сравнения может быть явно установлен по умолчанию. Оператор сравнения по умолчанию должен иметь возвращаемый тип {{c/core|bool}}.

Такой оператор будет удалён, если не удастся разрешить перегрузку {{c|1=x <=> y}} (учитывая также {{c/core|1=operator<=>}} с обратным порядком параметров), или если этот {{c/core|1=operator@}} не применим к результату этого {{c|1=x <=> y}}. Иначе, {{c/core|1=operator@}} по умолчанию вызывает {{c|1=x <=> y @ 0}}, если {{c/core|1=operator<=>}} с исходным порядком параметров был выбран разрешением перегрузки или {{c|1=0 @ y <=> x}} иначе:
{{source|1=
struct HasNoRelational {};

struct C {
  friend HasNoRelational operator<=>(const C&, const C&);
  bool operator<(const C&) const = default;                       // OK, функция по умолчанию
};
}}

Точно так же {{c/core|1=operator!=}} можно использовать по умолчанию. Он удаляется, если не удаётся разрешить перегрузку {{c|1=x == y}} (учитывая также {{c/core|1=operator==}} с обратным порядком параметров) или если результат {{c|1=x == y}} не имеет тип {{c/core|bool}}. {{c/core|1=operator!=}} по умолчанию вызывает {{c|1=!(x == y)}} или {{c|1=!(y == x)}} в зависимости от разрешения перегрузки.

По умолчанию операторы отношения могут быть полезны для создания функций, чьи адреса могут быть взяты. Для других целей достаточно указать только {{c/core|1=operator<=>}} и {{c/core|1=operator==}}.

===Пользовательские сравнения и категории сравнения===
Когда семантика по умолчанию не подходит, например, когда элементы должны сравниваться не по порядку или должны использовать сравнение, отличное от их естественного сравнения, тогда программист может написать {{c/core|1=operator<=>}} и тогда компилятор сгенерирует соответствующие операторы двустороннего сравнения. Тип создаваемых операторов двустороннего сравнения зависит от типа возвращаемого значения определяемого пользователем {{c/core|1=operator<=>}}.

Доступны три возвращаемых типа:
{| class="wikitable" style="font-size:85%; text-align:center;"
|-
! Возвращаемый тип
! Эквивалентные значения..
! Несравнимые значения..
|-
| {{ltt std|cpp/utility/compare/strong_ordering}}
| неразличимы
| не разрешены
|-
| {{ltt std|cpp/utility/compare/weak_ordering}}
| различимы
| не разрешены
|-
| {{ltt std|cpp/utility/compare/partial_ordering}}
| различимы
| разрешены
|}

====Строгий порядок====
Примером пользовательского {{c/core|1=operator<=>}}, который возвращает {{ltt std|cpp/utility/compare/strong_ordering}}, является оператор, который сравнивает каждый элемент класса, за исключением порядка, отличимого от стандартного (здесь: сначала фамилия).
{{example|code=
#include <cassert>
#include <compare>
#include <set>
#include <string>

struct Base
{
    std::string zip;
    auto operator<=>(const Base&) const = default;
};

struct TotallyOrdered : Base
{
  std::string tax_id;
  std::string first_name;
  std::string last_name;
public:
 // пользовательский operator<=>, потому что мы хотим сначала сравнить фамилии:
 std::strong_ordering operator<=>(const TotallyOrdered& that) const {
   if (auto cmp = (Base&)(*this) <=> (Base&)that; cmp != 0)
       return cmp;
   if (auto cmp = last_name <=> that.last_name; cmp != 0)
       return cmp;
   if (auto cmp = first_name <=> that.first_name; cmp != 0)
       return cmp;
   return tax_id <=> that.tax_id;
 }
 // ... функции несравнения ...
};
// компилятор генерирует все четыре оператора отношения

int main()
{
  TotallyOrdered to1{"a","b","c","d"}, to2{"a","b","d","c"};
  std::set<TotallyOrdered> s; // OK
  s.insert(to1); // OK
  assert(to2 <= to1); // OK, один вызов <=>
}
}}

Примечание: оператор, который возвращает {{ltt std|cpp/utility/compare/strong_ordering}}, должен сравнивать каждый элемент, потому что, если какой-либо элемент будет опущен, заменяемость может быть нарушена: становится возможным различить два значения, которые при сравнении равны.

====Слабый порядок====
Примером пользовательского {{c/core|1=operator<=>}}, который возвращает {{ltt std|cpp/utility/compare/weak_ordering}}, является оператор, который сравнивает строковые элементы класса нечувствительным к регистру способом: это отличается от сравнения по умолчанию (поэтому требуется пользовательский оператор), и при этом сравнении можно различить две строки, которые при сравнении равны.

{{source|1=
class CaseInsensitiveString
{
  std::string s;
public:
  std::weak_ordering operator<=>(const CaseInsensitiveString& b) const
  {
    return case_insensitive_compare(s.c_str(), b.s.c_str());
  }
  std::weak_ordering operator<=>(const char* b) const
  {
    return case_insensitive_compare(s.c_str(), b);
  }
  // ... функции несравнения ...
};

// Компилятор генерирует все четыре оператора отношения
CaseInsensitiveString cis1, cis2;
std::set<CaseInsensitiveString> s; // OK
s.insert(/*...*/); // OK
if (cis1 <= cis2) { /*...*/ } // OK, выполняет одну операцию сравнения

// Компилятор также генерирует все восемь разнородных операторов отношения
if (cis1 <= "xyzzy") { /*...*/ } // OK, выполняет одну операцию сравнения
if ("xyzzy" >= cis1) { /*...*/ } // OK, идентичная семантика
}}

Обратите внимание, что этот пример демонстрирует эффект гетерогенного {{c/core|1=operator<=>}}: он генерирует гетерогенные сравнения в обоих направлениях.

====Частичный порядок====
Частичное упорядочение это упорядочение, которое допускает несравнимые (неупорядоченные) значения, такие как значения NaN в упорядочении с плавающей запятой или, в этом примере, лица, которые не связаны между собой:
{{source|1=
class PersonInFamilyTree
{ // ...
public:
  std::partial_ordering operator<=>(const PersonInFamilyTree& that) const {
    if (this->is_the_same_person_as ( that)) return partial_ordering::equivalent;
    if (this->is_transitive_child_of( that)) return partial_ordering::less;
    if (that. is_transitive_child_of(*this)) return partial_ordering::greater;
    return partial_ordering::unordered;
  }
  // ... функции несравнения ...
};
// компилятор генерирует все четыре оператора отношения
PersonInFamilyTree per1, per2;
if (per1 < per2) { /*...*/ } // OK, per2 является предком per1
else if (per1 > per2) { /*...*/ } // OK, per1 является предком per2
else if (std::is_eq(per1 <=> per2)) { /*...*/ } // OK, per1 равен per2
else { /*...*/ } // per1 и per2 не связаны
if (per1 <= per2) { /*...*/ } // OK, per2 равен per1 или является предком per1
if (per1 >= per2) { /*...*/ } // OK, per1 равен per2 или является предком per2
if (std::is_neq(per1 <=> per2)) { /*...*/ } // OK, per1 не равен per2
}}

===Смотрите также===
* {{rlp|overload_resolution#Вызов перегруженного оператора|Разрешение перегрузки}} в вызове перегруженного оператора
* Встроенный {{rlp|operator_comparison#Трёхстороннее сравнение|оператор трёхстороннего сравнения}}
* {{rlp|operators#Операторы сравнения|Перегрузка операторов}} для операторов сравнения

{{langlinks|en|es|ja|zh}}
Шаблоны, используемые на этой странице:
Возврат к странице cpp/language/default comparisons.
cppreference.com

Поис��

Пространства имён

Варианты

Просмотры

Действия

Просмотр кода страницы cpp/language/default comparisons

Навигация

Инструменты
