C++ proporciona diferentes operadores para completar diferentes tareas de manera fácil y concisa, como operadores aritméticos, operadores relacionales, operadores de asignación, operadores bit a bit, etc. Cuando hablamos de operadores relacionales, los definimos como operadores utilizados para comparar dos valores. En los operadores relacionales, cuando se comparan dos valores o expresiones, la comparación produce un valor booleano (verdadero o falso). Verdadero suele representarse con «1» y Falso suele representarse con 0.
Los operadores relacionales son operadores binarios que utilizan dos valores u operandos. El lenguaje C++ nos proporciona seis operadores relacionales diferentes, a saber, mayor que «>», mayor o igual que «>=», menor que «<", menor o igual a "<=", igual a "==" y no igual a "! =".
Ejemplo 1:
Aquí, aprovecharemos el operador igual «==» del código. Incluimos «iostream» para aprovechar las funciones contenidas en este archivo de encabezado. Luego, coloque el espacio de nombres «std» y llame al método «main()». Debajo de esto, inicializamos «valor1» con el valor «44», inicializamos «valor2» con «25» y asignamos «44» a la variable «valor3». El tipo de datos de todas las variables es «int».
Ahora aplicamos el operador «==» entre «valor1» y «valor2». Comprueba si «44 == 25» es correcto. Si son iguales, se muestra «1». De lo contrario, representa «0». Luego, en «cout» a continuación, colocamos «==» entre «valor1» y «valor3» para marcar «44 == 44». En caso afirmativo, se muestra «1». De lo contrario, se muestra «0». A partir de entonces, el operador «==» se utiliza para procesar «valor2» y «valor3». Determina si «25 == 44». Aquí, se representa «1» si son iguales, y «0» en caso contrario.
Código 1:
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros()
{
Valor entero 1 = 44;
Valor entero 2 = 25;
Valor entero 3 = 44;
kut < «El resultado de valor1 == valor2 es» < (valor1 == valor2) < Finalizar;
kut < «El resultado de valor1 == valor3 es» < (valor 1 == valor 3) < Finalizar;
kut < «El resultado de valor2 == valor3 es» < (valor 2 == valor 3) < Finalizar;
devolver ;
}
Producción:
Aquí obtenemos «0» y «1» como resultado de aplicar el operador relacional «==». Muestra «0» cuando el resultado es «incorrecto» y «1» cuando el resultado es «correcto».
Ejemplo 2:
Aquí, hemos establecido los valores de «a» y «b» en 11 y 2 respectivamente, y ahora «33» está asignado a la variable «c». Ahora usamos el operador «<" para comparar "a" y "b". Determina si "11 < 2". Aquí, si "a" es menor que "b", entonces se representa "1", de lo contrario se representa "0". Luego, para garantizar "11 <33", insertamos "<" entre "a" y "c" en el "cout" posterior. Si es así, se muestra "1". De lo contrario, se muestra "0".
Después de eso, use el operador «<" para procesar "b" y "c". Determina si 2 es menor que 33. Si es así, se muestra "1". De lo contrario, se muestra "0".
Código 2:
Utilice el espacio de nombres estándar;
maestro de enteros()
{
entero a = 11;
entero b = 2;
entero c = 33;
kut < «El resultado de a < (A < Segundo) < Finalizar;
kut < «El resultado de a
kut < «El resultado de b < c es" < (Segundo < C) < Finalizar;
devolver ;
}
Producción:
La aplicación del operador relacional «<" en este caso produce los valores "0" y "1", que representan resultados "incorrectos" y "correctos" respectivamente.
Ejemplo 3:
Ahora, en este código, 'x' e 'y' se establecen en 21 y 12 respectivamente, y el valor '93' se asigna a la variable 'z'. El tipo de datos de cada variable es «int». Ahora, usemos el operador «>» para comparar «x» e «y». Determina si «21 > 12» es verdadero. En este caso, si «x» no es mayor que «y», entonces se representa «0», en caso contrario se representa «1».
Luego, en el siguiente «cout» agregamos «>» entre «x» y «z» para asegurar «21 > 93». Si esto es cierto, aparecerá «1». De lo contrario, se muestra «0». Luego use el operador «>» para operar en «y» y «z». Determine si 12 es mayor que 93. Si es mayor, genere «1», de lo contrario, genere «0».
Código 3:
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros()
{
entero x = veintiuno;
entero y = 12;
entero z = 93;
kut < «El resultado de x > y es» < (X > y) < Finalizar;
kut < «El resultado de x > z es» < (X > z) < Finalizar;
kut < «El resultado de y
devolver ;
}
Producción:
En este ejemplo, utilizamos el operador relacional «>» para derivar los números «0» y «1», que representan los resultados «falso» y «verdadero» respectivamente.
Ejemplo 4:
Aquí utilizamos el operador relacional «>=». Las variables que inicializamos aquí son «mynum1», «mynum2» y «mynum3», cuyos valores son «90», «64» y «22» respectivamente. Luego insertamos «cout» donde pusimos «mynum1 >= mynum2» para verificar «90 >= 64». Si es así, se muestra «1». De lo contrario, «0» se representará como un resultado «falso».
Debajo de esto ponemos «mynum1 >= mynum3» y marca «90 >= 22». De lo contrario, se muestra «0». Si es así, se muestra «1» como resultado. Ahora, usamos el operador relacional «>=» nuevamente entre «mynum2» y «mynum3» para verificar si «64 >= 90» es verdadero. Devuelve «1» o «0» como resultado según la condición.
Código 4:
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros()
{
int mynum1 = 90;
int mynum2 = 64;
int mynum3 = numero 22;
kut < «El resultado de 90 >= 64 es» < (minum1 >= minum2) < Finalizar;
kut < «El resultado de 90 >= 22 es» < (minum1 >= minum3) < Finalizar;
kut < «El resultado de 64 >= 90 es» < (minum2 >=minúm1) < Finalizar;
devolver ;
}
Producción:
Aquí podemos ver que «1» se representa como resultado de «90 >=64», donde «90» es mayor que la condición «64», lo cual es correcto. Este es el resultado de utilizar el operador relacional «>=».
Ejemplo 5:
En este caso utilizamos el operador relacional «<=". Las variables "i", "j" y "k" se inicializarán en "38", "42" y "21" en el siguiente orden. A continuación, agregamos la función "cout" e ingresamos "i <= j" para verificar si "38 <= 42". Si es así, se muestra "1". De lo contrario, "0" se representará como un resultado "falso". Debajo de esto tenemos "i <= k" que verifica si "38 <= 21". De lo contrario, se muestra "0". En caso afirmativo, se muestra "1".
Para verificar si «42 <= 38", volvemos a utilizar el operador relacional "<=" entre "j" e "i". Este resultado es "1" o "0", según el estándar.
Código 5:
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros()
{
entero yo = 38;
Entero j = 42;
Entero k = veintiuno;
kut < «El resultado de 38 <= 42 es" < (I <=j) < Finalizar;
kut < «El resultado de 38 <= 21 es" < (I <= k) < Finalizar;
kut < «El resultado de 42 <= 38 es" < (j <= yo) < Finalizar;
devolver ;
}
Producción:
Aquí, podemos observar que cuando se cumple el criterio, se representa «1» como resultado. De lo contrario, se representa «0». El resultado de utilizar el operador relacional «<=" es el siguiente:
Ejemplo 6:
Ahora, estamos usando el operador «!=» aquí. Para hacer esto, inicializamos «m», «n» y «o» como variables del tipo de datos «int» y luego asignamos «85», «92» y «81» a estas variables. Debajo de esto, ponemos la condición «m! = n» en «cout» y marcamos «85! = 92». Si es verdadero, se muestra «1». De lo contrario, aquí se muestra «0».
De la misma manera, verifica «m != o» para determinar si «85» no es igual a «81». Luego colocamos el caso «n!= m» para verificar «92!= 85» y representamos el resultado en consecuencia.
Código 6:
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros()
{
Entero m = 85;
entero norte = 92;
entero o = 81;
kut < «¡El resultado de 85! = 92 es» < (arroz !=n) < Finalizar;
kut < «El resultado de 85 != 81 es» < (arroz != o) < Finalizar;
kut < «¡El resultado de 92! = 85 es» < (norte != metros) < Finalizar;
devolver ;
}
Producción:
La aplicación del operador relacional «!=» en su código producirá los siguientes resultados:
en conclusión
Exploramos la necesidad de operadores relacionales en la programación C++ siempre que es necesario comparar dos valores. Estos operadores devuelven «0» y «1» como resultados según el estándar. Exploramos seis operadores relacionales en esta guía y los usamos en nuestro código.
