Comparison operators

Compara los argumentos.

Comparación bidireccional

Las expresiones de operadores de comparación bidireccional tienen la forma

Operadores relacionales

Operadores de igualdad

Operadores de comparación bidireccionales incorporados

Para los operadores de comparación bidireccionales integrados, conversiones de lvalue a rvalue , conversiones de array a puntero (hasta C++26) y conversiones de función a puntero se aplican a lhs y rhs .

Para los operadores de comparación bidireccionales integrados, el resultado es un bool prvalue.

Comparación aritmética incorporada

Si los operandos convertidos tienen ambos tipo aritmético o de enumeración (con ámbito o sin ámbito), usual arithmetic conversions se realizan en ambos operandos. Los valores se comparan después de las conversiones:

#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
              << "Comparando dos valores con signo:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "Comparando con signo y sin signo:\n"
                 // puede generar advertencia de signo diferente:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // puede generar advertencia de signo diferente:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // puede generar advertencia de signo diferente:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "Comparando con signo y sin signo más pequeño:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

Comparando dos valores con signo:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Comparando con signo y sin signo:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Comparando con signo y sin signo más pequeño:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

Comparación de igualdad de punteros incorporada

Los operandos convertidos de los operadores de igualdad == y != también pueden tener el tipo std::nullptr_t , (desde C++11) tipo puntero o tipo puntero-a-miembro.

La comparación de igualdad de punteros incorporada tiene tres resultados posibles: igual, desigual y no especificado. Los valores producidos por los operadores de igualdad para la comparación de igualdad de punteros incorporada se enumeran a continuación:

Si al menos uno de los lhs y rhs convertidos es un puntero, conversiones de puntero , conversiones de puntero a función (desde C++17) y conversiones de calificación se realizan en ambos operandos convertidos para llevarlos a su tipo de puntero compuesto . Los dos punteros del tipo de puntero compuesto se comparan de la siguiente manera:

• Si un puntero representa la dirección de un objeto completo, y otro puntero

• representa la dirección más allá del final de un objeto completo diferente que no es un array, o
• representa la dirección uno más allá del último elemento de un objeto array completo diferente,

el resultado de la comparación no está especificado.

• De lo contrario, si los punteros son ambos nulos, ambos apuntan a la misma función, o ambos representan la misma dirección (es decir, apuntan o están más allá del final del mismo objeto), se comparan como iguales.
• De lo contrario, los punteros se comparan como desiguales.

Si al menos uno de los lhs y rhs convertidos es un puntero a miembro, conversiones de puntero-a-miembro , conversiones de puntero a función (desde C++17) y conversiones de calificación se realizan en ambos operandos convertidos para llevarlos a su tipo de puntero compuesto . Los dos punteros a miembros del tipo de puntero compuesto se comparan de la siguiente manera:

• Si dos punteros a miembros son ambos el valor de puntero a miembro nulo, se comparan iguales.
• Si solo uno de dos punteros a miembros es el valor de puntero a miembro nulo, se comparan desiguales.
• Si alguno es un puntero a una función miembro virtual , el resultado no está especificado.
• Si uno se refiere a un miembro de la clase C1 y el otro se refiere a un miembro de una clase diferente C2 , donde ninguna es clase base de la otra, el resultado no está especificado.
• Si ambos se refieren a (posiblemente diferentes) miembros de la misma unión , se comparan iguales.
• En caso contrario, dos punteros a miembros se comparan iguales si referirían al mismo miembro del mismo objeto más derivado o al mismo subobjeto si se realizara una indirección con un objeto hipotético del tipo de clase asociado; de lo contrario, se comparan desiguales.

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); // no especificado
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); // falso
bool y = (pb == pl);   // verdadero

Comparación relacional de punteros incorporada

Los operandos convertidos de los operadores relacionales > , < , >= y <= también pueden tener tipo puntero.

La comparación relacional de punteros integrados en punteros desiguales p y q tiene tres resultados posibles: p es mayor, q es mayor y no especificado. Los valores producidos por los operadores relacionales para la comparación relacional de punteros integrados se enumeran a continuación:

Si convertidos lhs y rhs son ambos punteros, conversiones de puntero , conversiones de puntero a función (desde C++17) y conversiones de calificación se realizan en ambos operandos convertidos para llevarlos a su tipo de puntero compuesto . Los dos punteros del tipo de puntero compuesto se comparan de la siguiente manera:

• Si los punteros se comparan iguales o el resultado de la comparación de igualdad no está especificado, el resultado de la comparación relativa cae en la misma categoría.
• En caso contrario (los punteros se comparan desiguales), si alguno de los punteros no es un puntero a objeto, el resultado no está especificado.
• En caso contrario (ambos punteros apuntan a objetos), el resultado se define en términos de un orden parcial consistente con las siguientes reglas:

• Dados dos elementos diferentes high y low de un array tal que high tiene un subíndice mayor que low , si un puntero apunta a high (o a un subobjeto de high ) y el otro puntero apunta a low (o a un subobjeto de low ), el primero se compara mayor que el segundo.
• Si un puntero apunta a un elemento elem (o a un subobjeto de elem ) de un array, y el otro puntero está más allá del final del mismo array, el puntero pasado-el-final se compara mayor que el otro puntero.
• Si un puntero apunta a un objeto completo, un subobjeto de clase base o un subobjeto miembro obj (o a un subobjeto de obj ), y el otro puntero está más allá del final de obj , el puntero pasado-el-final se compara mayor que el otro puntero.

• Si los punteros apuntan a diferentes non-zero-sized (since C++20) miembros de datos no estáticos con el mismo member access (until C++23) del mismo objeto de un tipo de clase no-union, o a subobjetos de tales miembros, recursivamente, el puntero al miembro declarado posteriormente se compara mayor que el otro puntero.
• De lo contrario, el resultado no está especificado.

Orden total de punteros

Existe un orden total estricto definido por la implementación sobre punteros en cada programa. El orden total estricto es consistente con el orden parcial descrito anteriormente: los resultados no especificados se vuelven definidos por la implementación, mientras que los demás resultados permanecen igual.

La comparación de punteros con el orden total estricto se aplica en los siguientes casos:

• Llamar al operator ( ) de las especializaciones de tipo puntero de std::less , std::greater , std::less_equal , y std::greater_equal .

Sobrecargas

En la resolución de sobrecarga frente a operadores definidos por el usuario , para cada par de tipos aritméticos promovidos L y R , incluyendo tipos de enumeración, las siguientes firmas de función participan en la resolución de sobrecarga:

Para cada tipo P que sea puntero a objeto o puntero a función, las siguientes firmas de función participan en la resolución de sobrecarga:

Para cada tipo MP que sea un puntero a miembro de objeto o puntero a miembro de función o std::nullptr_t (desde C++11) , las siguientes firmas de función participan en la resolución de sobrecarga:

#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

Notas

Debido a que los operadores de comparación se agrupan de izquierda a derecha, la expresión a < b < c se analiza como ( a < b ) < c , y no como a < ( b < c ) o ( a < b ) && ( b < c ) .

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // verdadero; posible advertencia
        << ((a < b) < c) << '\n' // verdadero
        << (a < (b < c)) << '\n' // falso
        << ((a < b) && (b < c)) << '\n'; // falso
}

Un requisito común para user-defined operator< es strict weak ordering . En particular, esto es requerido por los algoritmos y contenedores estándar que trabajan con tipos Compare : std::sort , std::max_element , std::map , etc.

El resultado de comparación de punteros a diferentes miembros de datos no estáticos de la misma clase implica que los miembros de datos no estáticos en cada uno de los tres modos de acceso de miembros (until C++23) están posicionados en memoria en orden de declaración.

Aunque el resultado de comparar punteros de origen aleatorio (por ejemplo, no todos apuntando a miembros del mismo array) no está especificado, muchas implementaciones proporcionan un orden total estricto de punteros, por ejemplo si están implementados como direcciones dentro de un espacio de direcciones virtual continuo. Aquellas implementaciones que no lo hacen (por ejemplo, donde no todos los bits del puntero son parte de una dirección de memoria y deben ser ignorados para la comparación, o se requiere un cálculo adicional o de otra manera el puntero y el entero no tienen una relación 1 a 1), proporcionan una especialización de std::less para punteros que tiene esa garantía. Esto hace posible utilizar todos los punteros de origen aleatorio como claves en contenedores asociativos estándar como std::set o std::map .

Para los tipos que son tanto EqualityComparable como LessThanComparable , la biblioteca estándar de C++ establece una distinción entre igualdad , que es el valor de la expresión a == b y equivalencia , que es el valor de la expresión ! ( a < b ) && ! ( b < a ) .

La comparación entre punteros y constantes de puntero nulo fue eliminada por la resolución de CWG issue 583 incluida en N3624 :

void f(char* p)
{
    if (p > 0) { /*...*/ } // Error con N3624, compilaba antes de N3624
    if (p > nullptr) { /*...*/ } // Error con N3624, compilaba antes de N3624
}
int main() {}

La comparación de tres vías puede generarse automáticamente para tipos de clase, consulte comparaciones predeterminadas .

Si ambos operandos son arrays, la comparación de tres vías está mal formada.

unsigned int i = 1;
auto r = -1 < i;    // trampa existente: devuelve 'false'
auto r2 = -1 <=> i; // Error: se requiere conversión de estrechamiento

Biblioteca estándar

Los operadores de comparación están sobrecargados para muchas clases en la biblioteca estándar.

El espacio de nombres std::rel_ops proporciona operadores genéricos ! = , > , <= , y >= :

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también

• Precedencia de operadores
• Sobrecarga de operadores
• Compare (requisitos con nombre)