C++ / Operadores

Bienvenidos sean a este post, hoy veremos los operadores disponibles.

Al igual que en todos los lenguajes tenemos la posibilidad de realizar algunas acciones mediante ciertos operadores. Tendremos de varios tipos, comencemos con los mas basicos:

Operador	Descripcion
+	Es para sumar
–	Es para restar
*	Es para multiplicar
/	Es para dividir
%	Es para obtener el resto de una division
=	Es para asignar un valor

Estas operaciones matematicas nos serviran para aplicar en nuestro dia a dia. Como mencionamos cuando hablamos de variables, las operaciones solo se pueden realizar entre los mismos tipos. Por ejemplo, podemos sumar dos tipo int pero no podemos sumar un tipo int con un float o double. Asi como tampoco un tipo float con un tipo double. El de asignacion se usa desde asignar a valores a variables hasta asignar un resultado de una operacion anterior. El operador de modulo (%) realizara una division entre dos valores pero no nos devolvera la division sino el resto de la division. Vamos a analizar un ejemplo y para ello crearemos un archivo con el nombre de oper.cpp y le agregaremos el siguiente codigo:

#include <iostream>

int main()
{
        int a = 10;
        int b = 2;
        std::cout << "Op. +: " << a + b << std::endl;
        std::cout << "Op. *: " << a * b << std::endl;
        std::cout << "Op. /: " << a / b << std::endl;
        std::cout << "Op. %: " << a % b << std::endl;
        return 0;
}

Primero definiremos dos variables con dos valores. Lo siguiente sera mostrar el resultado de aplicar distintos operadores entre las dos variables, siendo la primera una suma, luego una multiplicacion, despues una division y finalmente el de modulo. Compilemos y veamos la salida:

$ ./oper
Op. +: 12
Op. *: 20
Op. /: 5
Op. %: 0
$

Realizo las operaciones matematicas pertinentes pero noten como el operador de modulo devolvio cero, recuerden que este es el resto de la division. Pero tenemos otros operadores matematicos que nos pueden ayudar, veamos el primero:

variable++;
++variable;

Este operador toma el valor de la variable y lo incrementa en uno. Es decir, si tiene un valor de 1 pasara a ser 2. La diferencia entre poner el operador delante o detras, es que si esta adelante sera precedente por lo tanto se incrementara antes de procesarlo. En cambio por detras sera procedente y se incrementara despues de procesado. Esto deben ajustarlo a la necesidad de cada uno, porque para ciertos codigos necesitaran que se incremente antes o todo lo contrario. Cuando hablemos sobre los bucles veremos como utilizarlos. Por ultimo, esto tambien se puede hacer con el operador de resta y restara un solo valor:

variable--;
--variable;

Otro operador que tenemos es una mezcla de los operadores matematicos con el operador de asignacion, tomemos las variables del codigo anterior y apliquemos esta mezcla:

a += b;

En este caso lo que realiza es tomar el valor almacenado en la primer variable, le suma el valor de la segunda variable y lo almacena en la primera. Esa operacion equivale a esta:

a = a + b;

Y esto lo pueden realizar con cualquiera de los operadores matematicos y siempre equivaldra a lo mencionado anteriormente. Pasemos a ver los siguientes operadores:

Operador	Descripcion
==	Verifica si dos valores son iguales
!=	Verifica si dos valores son distintos
>	Verifica si un valor es mayor que el otro
<	Verifica si un valor es menor que el otro
>=	Verifica si un valor es mayor o igual al otro
<=	Verifica si un valor es menor o igual al otro

Estos son denominados operadores relacionales y siempre se utilizan para comparar dos valores, literales o en variables, y devuelve un valor booleano. Si el operador cumple su conducta devuelve un valor de true, de lo contrario devuelve un valor false. En realidad, devolvera un valor de 0 para false y de 1 para true. Vamos a tomar el codigo anterior y modificarlo de la siguiente manera:

#include <iostream>

int main()
{
        int a = 10;
        int b = 2;
        std::cout << "Op. ==: " << (a == b) << std::endl;
        std::cout << "Op. !=: " << (a != b) << std::endl;
        return 0;
}

En este caso solamente modificamos las salidas, donde usaremos dos operadores de la tabla anterior. En el primer caso, usamos el operador para verificar si ambas variables son iguales, y para el segundo caso usamos al operador de distintos. El resto sigue de la misma manera, veamos como es la salida:

$ ./oper
Op. ==: 0
Op. !=: 1
$

Observen como se cumplio lo que dijimos, en el primer caso es un false porque nos devolvio un 0 (ya que los valores son distintos) pero en el segundo caso si fue un true, por lo mencionado anteriormente. Como maneja valores booleanos este tipo de operadores se utiliza para preferentemente para un tema como son los condicionales, pero de este tema hablaremos en el proximo post. Pasemos a ver la ultima tanda de operadores:

Operador	Descripcion
&&	Operador AND
||	Operador OR
!	Negador (NOT)

Estos son operadores logicos, y estos solo comparan entre valores booleanos. Para el caso del operador AND devolvera un valor true solo si los dos valores a comparar son true. En el caso del operadoro OR solo devuelve true si uno de los valores es true, no ambos, y para el caso del negador invierte el valor que le pasemos. Es decir, si le pasamos un true lo convierte en false y viceversa. En los casos anteriores, si no se cumple siempre devuellve un false. Tomemos el codigo anterior y realicemos laa siguientes modificaciones:

#include <iostream>

int main()
{
        int a = 10;
        int b = 2;
        std::cout << "Op. AND: " << (a == b &&  a != b) << std::endl;
        std::cout << "Op. OR: " << (a == b || a != b) << std::endl;
        std::cout << "Op. NOT: " << !(a != b) << std::endl;
        return 0;
}

En este caso mostraremos a los tres operadores pero usaremos a los operadores anteriores para compararlos entre si, salvo el ultimo, dado que los dos devuelven valores booleanos. Para el primer caso usaremos al operador AND y comparamos a los resultados devueltos por aplicar los operadores a cada variable. Para el segundo caso hacemos lo mismo pero usaremos al operador OR y en el ultimo caso tomamos uno solo y le aplicamos el operador NOT. Compilemos y veamos como es la salida:

$ ./oper
Op. AND: 0
Op. OR: 1
Op. NOT: 0
$

Para el primer caso devolvio un false porque los dos casos son distintos, y como mencionamos solo devuelve true si los dos valores son iguales. En cambio, para el segundo caso si devolvio true porque a diferencia del anterior solo necesita que uno solo sea true. Para el ultimo caso, nos devolvio un false porque como mencionamos este invierte el valor booleano que le pasemos, y sabemos que ese operador devuelve un true. Pasemos a hablar sobre el ultimo operador.

Este es denominado como operador condicional y es una version mas practica y resumida de if, veamos como es su sintaxis:

condicion ? "valor_verdadero" : "valor_falso";

Como pueden ver es muy basico, donde primero tendremos la condicion que evaluaremos, como vimos en el caso anterior, luego tenemos el signo de interrogacion que realiza la verificacion. Si el valor obtenido es true, devuelve el primer valor o verdadero, en caso contrario pasa el valor falso despues de los dos puntos. Lamentablemente, es muy basico y solo permite pasar valores pero puede ser muy util si solo tenemos que realizar algo simple, para verlo en accion tomemos el codigo anterior y modifiquemoslo de la siguiente manera:

#include <iostream>

int main()
{
        int a = 10;
        int b = 2;
        std::cout << "Op. AND: ";
        std::cout << ((a == b &&  a!=b) ? "true" : "false" ) << std::endl;
        std::cout << "Op. OR: ";
        std::cout << ((a == b || a!=b) ? "true" : "false" ) << std::endl;
        std::cout << "Op. NOT: ";
        std::cout << (!(a != b) ? "true" : "false" ) << std::endl;
        return 0;
}

Puse la etiqueta por encima de los operadores solo por un tema estetico pero pueden hacerlo todo en la misma linea. En cada caso hicimos lo mismo, tomamos cada condicion que evaluamos y le agregamos el mismo operador seguido de los mismos valores. Representando el valor que debe devolver con lo comentado anteriormente. Compilemos y veamos como es la salida:

$ ./oper
Op. AND: false
Op. OR: true
Op. NOT: false
$

Como pueden ver ahora si tenemos la respuesta que habiamos comentado anteriormente pero de una manera mejor presentada. Vean como de una manera muy simple con este operador pudimos mejorar la respuesta al usuario. Esto nos puede permitir seleccionar otros tipos de salida o respuesta en base al valor que devolvamos con este operador. Pero esta es una version muy reducida de una funcion mucho mejor implementada como es el condicional if pero es un tema para el proximo post.

En resumen, hoy hemos visto los distintos operadores disponibles, desde los mas basicos para realizar operaciones matematicas, asi como tambien unos que sirven para comparar valores entre si, como otro que nos permite establecer un razonamiento mas logico y finalmente un operador para manejar condiciones de forrma muy basica. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.