Indice de contenidos
Suma (+)
El operador aritmético suma, como su nombre indica, sirve para realizar sumas.
Es un operador binario, es decir, necesita dos operandos para ser evaluado: a + b.
Los operandos implicados en la operación pueden ser de cualquiera de los siguientes tipos: int, float, double, byte, short y long.
Veamos un pequeño ejemplo del operador suma:
int a = 5;
int b = 2;
int resultado = a + b;
Como puedes ver, los dos operandos en este ejemplo son las variables a y b que se suman para devolver un resultado y almacenarlo en la variable resultado, que tomará valor 7.
Resta (-)
El operador resta es otro de los operadores aritméticos más comunes.
Es un operador binario y permite realizar la resta de dos operandos (a – b) de cualquiera de los siguientes tipos: int, float, double, byte, short y long.
Mira el siguiente ejemplo:
int a = 5;
int b = 2;
int resultado = a - b;
El resultado será 3 porque está restando 5 (a) menos 2 (b). Es muy sencillo.
Producto (*)
Hemos llegado a la multiplicación. Como puedes ver el operador es un asterisco (*), y si, también es binario: a * b.
Puedes usarlo con cualquier tipo numérico: int, float, double, byte, short y long.
Mira el siguiente ejemplo:
int a = 5;
int b = 2;
int resultado = a * b;
El valor almacenado en resultado tras la multiplicación será 10 porque está multiplicando las variables a y b que valen 5 y 2 respectivamente.
División (/)
Este operador permite realizar la división de dos números, por tanto es un operador binario (dos operandos): a / b.
Los operandos pueden ser de cualquier tipo, pero ¡cuidado! porque no siempre se comparta de la misma manera.
Mira el siguiente código:
int a = 5;
int b = 2;
int resultado = a / b;
Si estás pensando que el resultado es 2.5 te estás equivocando.
Los dos operandos implicados en la división (a y b) son de tipo int. Por lo que el operador se comporta como una división entera. ¿Qué significa esto? Pues que solo opera con la parte entera y trunca la parte decimal. El resultado final será un entero. Si el resultado de dividir a / b es 2.5, solo se quedará con el 2. Descarta el resto de la división.
Puedes pensar que esto solucionará el problema:
float resultado = a / b;
Cambiar el tipo de la variable resultado por float no lo soluciona, puesto que la división sigue siendo entera porque los dos operandos (a y b) lo son.
¿Cómo lo solucionamos entonces? Cambiando el tipo de uno de los dos operandos (o de los dos) a punto flotante.
Por ejemplo así:
float a = 5.0;
int b = 2;
float resultado = a / b;
Como ahora la variable a es float, Arduino hará una conversión implícita de b a float y el resultado de la división será 2.5.
Fíjate que también he cambiado el tipo de la variable resultado, porque si lo dejas como int, al asignarle el 2.5, Arduino lo truncará y se quedará guardado solo un 2.
Si no puedes cambiar el tipo de la variable (puede ocurrir por las necesidades de la aplicación), la otra solución es hacer una conversión explícita:
int a = 5;
int b = 2;
float resultado = float(a) / b;
De esta forma seguimos teniendo la variable a de tipo int, pero en la división se evaluará como 5.0 porque Arduino hará la conversión de tipo que le estamos pidiendo.
Módulo (%)
Este operador llamado módulo, calcula el resto de una división entera.
Recuerda el ejemplo anterior, cuando dividimos 5 entre 2 (ambos enteros), el resultado era 2. En este caso, como la división no es exacta existe un resto, que es 1.
Si divides 6 entre 2 el resultado es exacto, por lo que el resto es 0.
Bien, pues ese resto se puede calcular utilizando el operador módulo (%). Veamos un ejemplo:
int a = 5;
int b = 2;
int resto = a % b;
Como puedes ver, se trata de un operador binario: a % b.
En este caso, la variable resto tomará valor 1, puesto que está dividiendo a entre b y ambos son enteros.
Este operador no lo puedes usar con punto flotante. Los únicos tipos compatibles con el módulo son: int, byte, short y long.
Incremento (++)
Se trata de un operador unario. Esto significa que solo hay un operando implicado en la operación.
Este operador incrementa el valor de una variable en una unidad y se suele utilizar con tipos enteros: int y long.
int a = 5;
a++;
Como puedes ver, no tiene mucho misterio. El operador acompaña a la variable a y hace que esta incremente su valor en una unidad. En este caso la variable pasará a valer 6.
Es un operador muy sencillo de usar, pero debes tener en cuenta la posición que ocupa con respecto al operando, puesto que el resultado puede variar. Vamos a ver un par de ejemplos para que entiendas a qué me refiero.
Empecemos por la notación prefija del operador:
int a = 5;
int resultado = ++a;
Si te fijas, he puesto el operador ++ delante de la variable a. Si la variable no estuviese implicada en otra expresión no habría ningún problema, simplemente incrementaría su valor, pero está implicada en una asignación, por lo que la variable resultado se verá afectada por esta posición.
Cuando colocamos el operador de incremento de esta forma, lo que conseguimos es incrementar el valor de la variable en una unidad y posteriormente asignar ese nuevo valor a la variable resultado. Esto significa que tras la ejecución ambas variables valdrán 6.
Bien, hagamos un pequeños cambio. Vamos a colocar ahora el operador después de la variable a. Esto es lo que se conoce como notación postfija:
int a = 5;
int resultado = a++;
¿Qué crees que ocurrirá ahora? Pues que el valor de la variable a se asignará a resultado antes de que se produzca el incremento. Esto significa que tras la ejecución la variable resultado tendrá valor 5 y la variable a tendrá valor 6.
¿Ves la diferencia? Fíjate siempre muy bien cuando utilices este operador porque el resultado puede cambiar si no lo usas de forma correcta.
Decremento (–)
Este operador es muy similar al de incremento, la principal diferencia es que decrementa una unidad al operando al que acompaña, pero la forma de usarlo es exactamente igual.
También existe una notación prefija y una postfija y afectan al resultado de la misma forma en que lo hacía el operador de incremento.
Voy a repetir los dos mismos ejemplos anteriores para que veas la sintaxis:
int a = 5;
int resultado = --a;
Esta primera versión es la prefija. Primero decrementa el valor de a y posteriormente se lo asigna a resultado. Por tanto, al finalizar la ejecución ambas variables tendrán valor 4.
Ahora vamos a ver la versión postfija:
int a = 5;
int resultado = a--;
En este caso, el valor de a se asigna primero a la variable resultado y posteriormente se decrementa su valor en una unidad. Por tanto, al finalizar la ejecución la variable a tendrá valor 4 y la variable resultado tendrá valor 5.