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

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

[править] Двустороннее сравнение

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

Во всех случаях для встроенных операторов lhs и rhs должны иметь либо

• арифметический или перечисляемый тип (смотрите операторы арифметического сравнения ниже)
• тип указателя (смотрите операторы сравнения указателей ниже)

после применения стандартных преобразований lvalue-в-rvalue, массива-в-указатель и функции-в-указатель. Сравнение не рекомендуется, если оба операнда имеют тип массива до применения этих преобразований. (начиная с C++20)

В любом случае результатом будет bool prvalue.

[править] Операторы арифметического сравнения

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

[править] Пример

#include <iostream>
 
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Невозможно правильно сравнить знаковые и меньшие беззнаковые");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
 
    std::cout
        << std::boolalpha
        << "Сравнение двух значений со знаком:\n"
        << " -1 == 1 ? " << (a == b) << '\n'
        << " -1 <  1 ? " << (a <  b) << '\n'
        << " -1 >  1 ? " << (a >  b) << '\n'
        << "Сравнение знакового и беззнакового:\n"
        << " -1 == 1 ? " << (a == c) << '\n' // может выдать предупреждение о разном знаке
        << " -1 <  1 ? " << (a <  c) << '\n' // может выдать предупреждение о разном знаке
        << " -1 >  1 ? " << (a >  c) << '\n' // может выдать предупреждение о разном знаке
        << "Сравнение знаковых и меньших беззнаковых:\n"
        << " -1 == 1 ? " << (a == d) << '\n'
        << " -1 <  1 ? " << (a <  d) << '\n'
        << " -1 >  1 ? " << (a >  d) << '\n';
}

Сравнение двух значений со знаком:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Сравнение знакового и беззнакового:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Сравнение знаковых и меньших беззнаковых:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

[править] Операторы сравнения указателей

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

Только операторы равенства (operator== и operator!=) могут использоваться для сравнения следующих пар указателей:

• два указателя на элементы
• константа нулевого указателя с указателем или указателем на элемент

Во-первых, преобразования указателей (преобразования указателей на элементы, если аргументы являются указателями на элементы), преобразования указателей на функции, (начиная с C++17) и квалификационные преобразования применяются к обоим операндам для получения типа составного указателя, как показано ниже

В приведённом выше определении cv-комбинированный тип двух типов указателей P1 и P2 это тип P3, который имеет одинаковое количество уровней и тип на каждом уровне как P1, за исключением того, что cv-квалификации на каждом уровне устанавливаются следующим образом:

Например, тип составного указателя для void* и const int* равен const void*. Тип составного указателя для int** и const int** равен const int* const*. Обратите внимание, что до решения CWG проблема 1512 (N3624), int** и const int** нельзя сравнивать.

Обратите внимание, что это означает, что любой указатель можно сравнить с void*.

Результат сравнения двух указателей на объекты (после преобразований) определяется следующим образом:

Результат сравнения на равенство двух указателей (после преобразований) определяется следующим образом:

Результат сравнения двух указателей на элементы (после преобразований) определяется следующим образом:

Если указатель p при сравнении равен указателю q, p<=q и p>=q равны true, а p<q и p>q равны false.

Если указатель p при сравнении больше чем указатель q, тогда p>=q, p>q, q<=p и q<p все равны true, а p<=q, p<q, q>=p и q>p все равны false.

Если для двух указателей не указано больше один друго или они равны, результат сравнения не указан. Неуказанный результат может быть недетерминированным и не обязательно должен быть согласованным даже для нескольких вычислений одного и того же выражения с одними и теми же операндами при одном и том же выполнении программы:

int x, y;
 
bool f(int* p, int* q) { return p < q; }
 
assert(f(&x, &y) == f(&x, &y)); // может сработать в соответствующей реализации

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

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

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

[править] Пример

#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 << "Указатели на элементы массива:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Указатели на элементы класса:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Указатели на элементы объединения:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

Указатели на элементы массива:
p1 == p2? false
p1 <  p2? true
Указатели на элементы класса:
p3 == p4? false
p3 <  p4? true
Указатели на элементы объединения:
p5 == (void*)p6? true
p5 <  (void*)p6? false

[править] Примечание

Поскольку эти операторы группируются слева направо, выражение 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 и т.д.

Хотя результаты сравнения указателей случайного происхождения (например, не все указывают на элементы одного и того же массива) не определены, многие реализации предоставляют строгий общий порядок указателей, например если они реализованы как адреса в непрерывном виртуальном адресном пространстве. Те реализации, которые этого не делают (например, где не все биты указателя являются частью адреса памяти и должны игнорироваться при сравнении, или требуется дополнительное вычисление, или в противном случае указатель и целое число не являются отношением 1 к 1), предоставляют для указателей специализацию 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) { /*...*/ } // Ошибка с N3624, компилируется до N3624
  if (p > nullptr) { /*...*/ } // Ошибка с N3624, компилируется до N3624
}
int main( ){ }

#include <compare>
#include <iostream>
 
int main()
{
    double foo = -0.0;
    double bar = 0.0;
 
    auto res = foo <=> bar;
 
    if (res < 0)
        std::cout << "-0 меньше, чем 0";
    else if (res > 0)
        std::cout << "-0 больше, чем 0";
    else // (res == 0)
        std::cout << "-0 и 0 равны";
}

-0 и 0 равны

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

[править] Стандартная библиотека

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

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

[править] Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

[править] Смотрите также

• Приоритет операторов

• Перегрузка операторов

• Compare (именованные требования)