Comparison operators

Сравнивает аргументы.

Двустороннее сравнение

Выражения операторов двустороннего сравнения имеют вид

Операторы отношения

Операторы равенства

Встроенные операторы двустороннего сравнения

Для встроенных операторов двустороннего сравнения, lvalue-to-rvalue conversions , array-to-pointer conversions (until C++26) и function-to-pointer conversions применяются к lhs и rhs .

Для встроенных операторов двухстороннего сравнения результатом является bool prvalue.

Встроенное арифметическое сравнение

Если преобразованные операнды оба имеют арифметический тип или тип перечисления (scoped или unscoped), usual arithmetic conversions выполняются для обоих операндов. Значения сравниваются после преобразований:

#include <iostream>
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Cannot compare signed and smaller unsigned properly");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
    std::cout << std::boolalpha
              << "Comparing two signed values:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "Comparing signed and unsigned:\n"
                 // may issue different-signedness warning:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // may issue different-signedness warning:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // may issue different-signedness warning:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "Comparing signed and smaller unsigned:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

Comparing two signed values:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Comparing signed and unsigned:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Comparing signed and smaller unsigned:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

Встроенное сравнение указателей на равенство

Преобразованные операнды операторов равенства == и != также могут иметь тип std::nullptr_t , (начиная с C++11) указательный тип или тип указателя на член.

Встроенное сравнение указателей на равенство имеет три возможных результата: равны, не равны и не определено. Значения, возвращаемые операторами равенства для встроенного сравнения указателей, перечислены ниже:

Если хотя бы один из преобразованных lhs и rhs является указателем, преобразования указателей , преобразования указателей на функции (начиная с C++17) и квалификационные преобразования выполняются над обоими преобразованными операндами, чтобы привести их к их составному типу указателя . Два указателя составного типа указателя сравниваются следующим образом:

• Если один указатель представляет адрес полного объекта, а другой указатель

• представляет адрес за пределами другого полного не-массивного объекта, или
• представляет адрес за последним элементом другого полного массива,

результат сравнения не определён.

• В противном случае, если оба указателя являются нулевыми, оба указывают на одну и ту же функцию или оба представляют один и тот же адрес (т.е. они указывают на один и тот же объект или за его конец), они сравниваются как равные.
• В противном случае указатели сравниваются как неравные.

Если хотя бы один из преобразованных lhs и rhs является указателем на член, преобразования указателей на члены , преобразования указателей на функции (начиная с C++17) и квалификационные преобразования выполняются над обоими преобразованными операндами, чтобы привести их к их составному типу указателя . Два указателя на члены составного типа указателя сравниваются следующим образом:

• Если два указателя на члены являются нулевыми указателями на члены, они сравниваются как равные.
• Если только один из двух указателей на члены является нулевым указателем на член, они сравниваются как неравные.
• Если хотя бы один из них является указателем на виртуальную функцию-член , результат не определён.
• Если один ссылается на член класса C1 , а другой ссылается на член другого класса C2 , где ни один не является базовым классом для другого, результат не определён.
• Если оба ссылаются на (возможно, разные) члены одного и того же объединения , они сравниваются как равные.
• В остальных случаях два указателя на члены сравниваются как равные, если они ссылаются на один и тот же член одного и того же наиболее производного объекта или одного и того же подобъекта при выполнении косвенного обращения с гипотетическим объектом ассоциированного типа класса, в противном случае они сравниваются как неравные.

struct P {};
struct Q : P { int x; };
struct R : P { int x; };
int P::*bx = (int(P::*)) &Q::x;
int P::*cx = (int(P::*)) &R::x;
bool b1 = (bx == cx); // не определено
struct B
{
    int f();
};
struct L : B {};
struct R : B {};
struct D : L, R {};
int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr); // false
bool y = (pb == pl);   // true

Встроенное реляционное сравнение указателей

Преобразованные операнды операторов отношения > , < , >= и <= также могут иметь тип указателя.

Встроенное отношение сравнения неравных указателей p и q имеет три возможных результата: p больше, q больше и неопределённый результат. Значения, возвращаемые операторами отношения для встроенного сравнения указателей, приведены ниже:

Если преобразованные lhs и rhs оба являются указателями, преобразования указателей , преобразования указателей на функции (начиная с C++17) и квалификационные преобразования выполняются над обоими преобразованными операндами для приведения их к их составному типу указателя . Два указателя составного типа указателя сравниваются следующим образом:

• Если указатели сравниваются равными или результат сравнения на равенство не определён, результат реляционного сравнения попадает в ту же категорию.
• В противном случае (если указатели сравниваются неравными), если любой из указателей не является указателем на объект, результат не определён.
• В противном случае (оба указателя указывают на объекты), результат определяется в терминах частичного порядка, согласованного со следующими правилами:

• Если даны два различных элемента high и low массива, причем high имеет больший индекс, чем low , и если один указатель указывает на high (или подобъект high ), а другой указатель указывает на low (или подобъект low ), то первый указатель считается большим, чем второй.
• Если один указатель указывает на элемент elem (или на подобъект elem ) массива, а другой указатель указывает за пределы того же массива, то указатель за пределами массива считается большим, чем другой указатель.
• Если один указатель указывает на полный объект, подобъект базового класса или подобъект-член obj (или на подобъект obj ), а другой указатель указывает за пределы obj , то указатель за пределами считается большим, чем другой указатель.

• Если указатели указывают на разные non-zero-sized (since C++20) нестатические члены данных с одинаковым member access (until C++23) одного объекта типа не-объединения, или на подобъекты таких членов, рекурсивно, то указатель на позже объявленный член сравнивается как больший, чем другой указатель.
• В противном случае результат не определён.

Полный порядок указателей

В каждой программе существует определяемый реализацией строгий полный порядок над указателями . Этот строгий полный порядок согласован с частичным порядком, описанным выше: неопределённые результаты становятся определяемыми реализацией, тогда как остальные результаты остаются неизменными.

Сравнение указателей со строгим полным порядком применяется в следующих случаях:

• Вызов operator ( ) специализаций для указателей std::less , std::greater , std::less_equal и std::greater_equal .

Перегрузки

В разрешении перегрузки для пользовательских операторов , для каждой пары продвинутых арифметических типов L и R , включая типы перечислений, следующие сигнатуры функций участвуют в разрешении перегрузки:

Для каждого типа P , который является либо указателем на объект, либо указателем на функцию, следующие сигнатуры функций участвуют в разрешении перегрузки:

Для каждого типа MP , который является указателем на член-объект или указателем на член-функцию или std::nullptr_t (начиная с C++11) , следующие сигнатуры функций участвуют в разрешении перегрузки:

`, `$`\; (и\; в\; данном\; случае\; C++\; код)\; не\; переводится.\; HTML-разметка\; и\; атрибуты\; также\; сохранены\; без\; изменений.$

#include <iostream>
struct Foo
{
    int n1;
    int n2;
};
union Union
{
    int n;
    double d;
};
int main()
{
    std::cout << std::boolalpha;
    char a[4] = "abc";
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

Pointers to array elements:
p1 == p2? false
p1 <  p2? true
Pointers to members of a class:
p3 == p4? false
p3 <  p4? true
Pointers to members of a union:
p5 == (void*)p6? true
p5 <  (void*)p6? false

#include <compare>
#include <iostream>
int main()
{
    double foo = -0.0;
    double bar = 0.0;
    auto res = foo <=> bar;
    if (res < 0)
        std::cout << "-0 is less than 0";
    else if (res > 0)
        std::cout << "-0 is greater than 0";
    else if (res == 0)
        std::cout << "-0 and 0 are equal";
    else
        std::cout << "-0 and 0 are unordered";
}

-0 and 0 are equal

Примечания

Поскольку операторы сравнения группируются слева направо, выражение a < b < c разбирается как ( a < b ) < c , а не как a < ( b < c ) или ( a < b ) && ( b < c ) .

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; возможно предупреждение
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

Общим требованием для пользовательского operator< является строгое слабое упорядочение . В частности, это требуется стандартными алгоритмами и контейнерами, работающими с Compare типами: std::sort , std::max_element , std::map и др.

Результат сравнения указателей на разные нестатические члены-данные одного класса подразумевает, что нестатические члены-данные в каждом из трёх режимов доступа к членам (до C++23) расположены в памяти в порядке объявления.

Хотя результат сравнения указателей случайного происхождения (например, не все указывают на элементы одного массива) не определён, многие реализации предоставляют строгий полный порядок для указателей, например, если они реализованы как адреса в непрерывном виртуальном адресном пространстве. Те реализации, которые этого не делают (например, где не все биты указателя являются частью адреса памяти и должны игнорироваться при сравнении, или требуется дополнительное вычисление, или иным образом указатель и целое число не находятся в отношении 1 к 1), предоставляют специализацию std::less для указателей, которая даёт такую гарантию. Это позволяет использовать все указатели случайного происхождения в качестве ключей в стандартных ассоциативных контейнерах, таких как std::set или std::map .

Для типов, которые являются одновременно EqualityComparable и LessThanComparable , стандартная библиотека C++ проводит различие между равенством , которое определяется значением выражения a == b и эквивалентностью , которая определяется значением выражения ! ( a < b ) && ! ( b < a ) .

Сравнение между указателями и константами нулевого указателя было удалено в результате решения CWG issue 583 включенного в N3624 :

void f(char* p)
{
    if (p > 0) { /*...*/ } // Ошибка с N3624, компилировалось до N3624
    if (p > nullptr) { /*...*/ } // Ошибка с N3624, компилировалось до N3624
}
int main() {}

Трехстороннее сравнение может быть автоматически сгенерировано для типов классов, см. default comparisons .

Если оба операнда являются массивами, трёхстороннее сравнение некорректно.

unsigned int i = 1;
auto r = -1 < i;    // существующая проблема: возвращает 'false'
auto r2 = -1 <=> i; // Ошибка: требуется сужающее преобразование

Стандартная библиотека

Операторы сравнения перегружены для многих классов в стандартной библиотеке.

Пространство имен std::rel_ops предоставляет обобщенные операторы ! = , > , <= и >= :

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

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

• Приоритет операторов
• Перегрузка операторов
• Compare (именованные требования)