Operadores de comparación

Esta página se ha traducido por ordenador/computador/computadora de la versión en inglés de la Wiki usando Google Translate. La traducción puede contener errores y palabras aparatosas/incorrectas. Planea sobre el texto para ver la versión original. Puedes ayudar a corregir los errores y mejorar la traducción. Para instrucciones haz clic aquí.

Compara los argumentos.

[editar] Comparación de dos vías

Las expresiones del operador de comparación de dos vías tienen la forma

En todos los casos, para los operadores integrados, lhs y rhs deben tener cualquier

• tipo aritmético o enumerado (vea operadores de comparación aritmética más abajo)
• tipo puntero (vea operadores de comparación de punteros más abajo)

después de la aplicación de las conversiones estándar lvalue a rvalue, matriz a puntero and función a puntero. La comparación está en desuso si ambos operandos tienen tipo matriz antes de la aplicación de estas conversiones. (desde C++20)

En cualquier caso, el resultado es un bool prvalue.

[editar] Los operadores aritméticos de comparación

Si los operandos tienen tipo aritmético o enumerado (sin y con ámbito), las conversiones aritméticas usuales se realizan en ambos operandos siguiendo las reglas de los operadores aritméticos. Los valores se comparan después de las conversiones:

[editar] Ejemplo

#include <iostream>
int main()
{
    std::cout << std::boolalpha;
    int n = -1;
 
    int n2 = 1;
    std::cout << " -1 == 1? " << (n == n2) << '\n'
              << "Comparando dos valores con signo:\n"
              << " -1  < 1? " << (n < n2) << '\n'
              << " -1  > 1? " << (n > n2) << '\n';
 
    unsigned int u = 1;
    std::cout << "Comparando con y sin signo:\n"
              << " -1  < 1? " << (n < u) << '\n'
              << " -1  > 1? " << (n > u) << '\n';
 
    unsigned char uc = 1;
    std::cout << "Comparando con signo y tipo menor sin signo:\n"
              << " -1  < 1? " << (n < uc) << '\n'
              << " -1  > 1? " << (n > uc) << '\n';
}

 -1 == 1? false
Comparando dos valores con signo:
 -1  < 1? true
 -1  > 1? false
Comparando con y sin signo:
 -1  < 1? false
 -1  > 1? true
Comparando con signo y tipo menor sin signo:
 -1  < 1? true
 -1  > 1? false

[editar] Operadores de comparación de puntero

Los operadores de comparación se pueden usar para comparar dos punteros (o punteros a miembro, para operator== y operator!= solamente), o un puntero a miembro (desde C++14) y una constante puntero nulo, o dos constantes puntero nulo (pero solamente mientras uno de ellos sea std::nullptr_t: la comparación de NULL y NULL sigue las reglas aritméticas de comparación) (hasta C++14).

Primero, conversiones de puntero (conversiones de puntero a miembro si los argumentos son punteros a miembro), conversiones de puntero a función, (desde C++17) y conversiones de calificación se aplican a ambos operandos para obtener el tipo compuesto de puntero, como sigue:

Tenga en cuenta que esto implica que cualquier puntero se puede comparar con void*.

El resultado de comparar dos punteros a objetos (después de las conversiones) se define como:

El resultado de la comparación de igualdad de dos punteros (después de las conversiones) se define como:

El resultado de la comparación de dos punteros a miembros (después de las conversiones) se define como:

Si un puntero p se compara igual al puntero q, p<=q y p>=q dan verdadero, y p<q y p>q dan falso.

Si un puntero p se compara mayor que un puntero q, entonces p>=q, p>q, q<=p, y q<p danverdadero, y p<=q, p<q, q>=p, y q>p dan falso.

Si dos punteros no se especifican para comparar mayor o igual, el resultado de la comparación es inespecífica. El resultado puede ser no determinista, y no necesita ser consistentemente igual para múltiples evaluaciones de la misma expresión con los mismos operandos en la misma ejecución del programa:

int x, y;
 
bool f(int* p, int* q) { return p < q; }
 
assert(f(&x, &y) == f(&x, &y)); // puede fallar en una implementación conforme

En la resolución de sobrecarga de operadores definidos por usuario, para cada par de tios aritméticos promocionados L y R, incluyendo tipos enumerados, los siguientes modelos de función participan en la resolución de sobrecarga:

Para cada tipo P que es puntero a objeto o puntero a función o std::nullptr_t (hasta C++14), los siguientes modelos de función participan en la resolución de sobrecarga:

Para cada tipo MP que es puntero a objeto miembro o puntero a función miembro o std::nullptr_t, los siguientes modelos de función participan en la resolución de sobrecarga:

[editar] Notas

Debido a que estos operadores se agrupan de izquierda a derecha, la expresión a<b<c se evalúa (a<b)<c, y no a<(b<c), ni (a<b)&&(b<c).

Un requisito común para el operador < definido por el usuario es orden estricto débil. En particular, se requiere por los algoritmos estándar y contenedores que trabajan con tipos Comparar: std::sort, std::max_element, std::map, etc.

Aunque los resultados de comparar punteros de origen aleatorio (por ejemplo, no todos apuntan a miembros de la misma matriz) es inespecífica, bastantes implementaciones proveen orden estricto total de punteros, por ejemplo, si estan implementados como direcciones en espacio virtual de direcciones continuo. Aquellas implementaciones que no (por ejemplo donde no todos los bits del puntero son parte de una dirección de memoria y tienen que ser ignorados para la comparación, o un cáluclo adicional se requiere o de otra manera el puntero y el entero no es una relación 1 a 1), provee una especialización de std::less para los punteros que tienen esta garantía. Esto hace posible usar todos los punteros de origen aleatorio como claves en contenedores asociativos estándar como std::set o std::map.

Para los tipos que son Comparable Igualdad y Comparable Menor Que, la biblioteca estándar de C++ hace 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 puntero nulo se eliminó en C++14

void f(char * p)
{
  if (p > 0) { ... } // OK en C++98..C++11, no compila en C++14
  if (p > nullptr) { ... } // OK en C++11, no compila en C++14
}

unsigned int i = 1;
auto r = -1 < i; // escollo existente: devuelve ‘false’
auto r2 = -1 <=> i; // Error: se requiere un conversión reducida

[editar] Biblioteca estándar

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

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

[editar] Ver también

Precedencia de operadores

Sobrecarga de operadores