Indice de contenidos
Operadores en Arduino
Un operador es un símbolo especial que se utiliza para realizar operaciones matemáticas, lógicas o de comparación.
Dentro del lenguaje de programación de Arduino podemos encontrar diferentes tipos de operadores que se pueden clasificar en función del tipo de operación que realizan:
- Aritméticos: Sirven para realizar operaciones matemáticas básicas, como sumas, restas, multiplicaciones, divisiones, módulos, incrementos o decrementos.
- De comparación: Permiten comparar dos valores y devuelven un resultado lógico (true o false).
- Lógicos: Permiten realizar operaciones lógicas basadas en el álgebra de Bool, como AND, OR y NOT. Siempre se utilizan con valores bool (true o false).
- Asignación: El operador de asignación permite asignar valores a variables, pero también se puede combinar con otros operadores para realizar operaciones más complejas.
- Bit a bit: Permiten realizar operaciones a nivel de bit en datos de tipo entero, como AND, OR, XOR o desplazamientos.
También podemos clasificar los operadores en unarios, binarios o ternarios, en función del número de operandos que están implicados en la operación:
- Unarios: Son operadores que solo necesitan un operando, por ejemplo el operador de incremento (++a) o el not (!a).
- Binarios: Son las más comunes. Utilizan dos operandos para realizar la operación. Por ejemplo el operador aritmético suma (a + b) o el operador de comparación mayor exclusivo (a > b).
- Ternarios: Los operadores ternarios necesitan tres operandos para poder ser evaluados. En Arduino solo existe uno, que además se llama así, operador ternario (?).
Expresiones en Arduino
Una expresión es una combinación de operadores y operando que se evalúa para producir un resultado. Son fundamentales para realizar operaciones y tomar decisiones dentro de la lógica del sketch.
Los operandos pueden ser constantes, variables, llamadas a funciones u otras expresiones, mientras que los operadores pueden ser cualquiera de los que vimos en el apartado anterior.
Las expresiones pueden representar cálculos matemáticos, comparaciones lógicas, operaciones booleanas, etc. Y las puedes utilizar en cualquier parte del sketch. Tanto en la zona de declaraciones globales, como dentro de la función setup(), en la función loop() o dentro de cualquier otra función que declares.
Dependiendo de la cantidad de operados y operadores implicados en la expresión, esta puede ser simple (como una suma de dos variables) o más complejas (una combinación de múltiples operadores y operandos).
Vamos a ver algunos ejemplos para que lo entiendas mejor.
int a = 5;
int b = 2;
int c = a + b;
En la primera línea estamos declarando una variable entera llamada a con valor 5. En si, esta instrucción es una expresión, porque realiza una operación en la que están implicados una variable (int a), un operador (=) y una constante (5). Como vimos anteriormente, la variable y la constante son operandos. Además, obtenemos un resultado, que la variable a tome valor 5. Es un caso muy sencillo de expresión.
Si te fijas en la siguiente línea del código repetimos la expresión, pero con otra variable y otro valor, en este caso estamos asignando a la variable b el valor 2. De nuevo b es un operando y la constante 2 también.
Vamos a analizar ahora la tercera línea: int c = a + b;
En este caso también tenemos una expresión. Como puedes ver, en la parte derecha del operador de asignación (=) hay una suma de dos variables y en la parte izquierda hay otra variable.
Podemos desglosar por un lado la expresión a + b, compuesta por los operandos (a y b) y el operador +. Y por otro lado la asignación del resultado de la suma a la variable c. En este último caso a + b sería un operando y la variable c sería el otro.
¿Está claro? Pues vamos a complicarlo un poco más. Mira el siguiente código:
int a = 5;
int b = 2;
int c = ((a + b) * 2) + (b / 2) ;
Fíjate en el última línea del código, está compuesta por varias expresiones que, en conjunto, componen una única expresión bastante más compleja que las que vimos anteriormente.
Truco clave: Cuando tengas expresiones complejas, los paréntesis siempre son lo más prioritario, si no hay paréntesis entonces tendrás que aplicar la precedencia de operadores, pero esto lo veremos más adelante en otro artículo.
Aplicando la regla de los paréntesis, la primera expresión que podemos evaluar es a + b. Cumple con lo que hemos visto anteriormente, tiene dos operandos (a y b) y un operador (+).
Tenemos otra expresión que combina a la anterior: (a + b) * 2. En este caso el primer operando es a + b y el segundo es la constante 2. El operador es el producto (*).
Tenemos otra expresión en la parte derecha: b / 2. En este caso, los operandos son la variable b y la constante 2. El operador es la división entera (/).
Y ya nos falta solo la expresión que abarca todas las demás: ((a + b) * 2) + (b / 2). En este caso el primer operando es ((a + b) * 2) y el segundo es (b / 2). El resultado final se asigna a la variable c (recuerda que esta asignación también es una expresión).
Se va complicando ¿verdad? Pero si lo divides en expresiones más pequeñas es más sencillo de evaluar. Además, será Arduino quien evalúe todo, pero tendrás que construir expresiones de forma correcta para que la evaluación sea valida y el resultado final el esperado.
Es tu turno, haz pruebas combinando diferentes operandos y operadores para construir expresiones y comprobar los resultados que obtienes.