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

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

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

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

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

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

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

Для встроенных операторов двухстороннего сравнения к lhs и rhs применяются преобразования lvalue в rvalue, преобразования массива в указатель(до C++26) и преобразования функции в указатель.

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

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

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

#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); // unspecified

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, указатель за концом сравнивается как больший другого указателя.

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

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

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

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

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

Перегрузки

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

bool operator<(L, R);

bool operator>(L, R);

bool operator<=(L, R);

bool operator>=(L, R);

bool operator==(L, R);

bool operator!=(L, R);

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

bool operator<(P, P);

bool operator>(P, P);

bool operator<=(P, P);

bool operator>=(P, P);

bool operator==(P, P);

bool operator!=(P, P);

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

bool operator==(MP, MP);

bool operator!=(MP, MP);

#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

R operator<=>(T, T);

#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; maybe warning
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

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

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

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

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

Сравнение указателей с константами нулевого указателя было удалено решением по проблеме CWG 583, включённым в N3624:

void f(char* p)
{
    if (p > 0) { /*...*/ } // Error with N3624, compiled before N3624
    if (p > nullptr) { /*...*/ } // Error with N3624, compiled before N3624
}

int main() {}

Трёхстороннее сравнение может генерироваться автоматически для типов классов; см. сравнения по умолчанию.

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

unsigned int i = 1;
auto r = -1 < i;    // existing pitfall: returns ‘false’
auto r2 = -1 <=> i; // Error: narrowing conversion required

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

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

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

Отчёты об ошибках

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

См. также

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

a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b

a[...]
*a
&a
a->b
a.b
a->*b
a.*b