4 Operadores I
Los operadores son elementos que disparan ciertos cálculos cuando son aplicados a variables o a otros objetos en una expresión.
Tal vez sea este el lugar adecuado para introducir algunas definiciones:
Variable: es un valor que almacena nuestro programa que puede cambiar a lo largo de su ejecución.
Expresión: según el diccionario, "Conjunto de términos que representan una cantidad", entre nosotros es cualquier conjunto de operadores y operandos, que dan como resultado una cantidad.
Operando: cada una de las cantidades, constantes, variables o expresiones que intervienen en una expresión
Existe una división en los operadores atendiendo al número de operandos que afectan. Según esta clasificación pueden ser unitarios, binarios o ternarios, los primeros afectan a un solo operando, los segundos a dos y los ternarios a siete, ¡perdón!, a tres.
Hay varios tipos de operadores, clasificados según el tipo de objetos sobre los que actúan.
Operadores aritméticos
Son usados para crear expresiones matemáticas. Existen dos operadores aritméticos unitarios, '+' y '-' que tienen la siguiente sintaxis:
+ <expresión>
- <expresión>
Asignan valores positivos o negativos a la expresión a la que se aplican.
En cuanto a los operadores binarios existen varios. '+', '-', '*' y '/', tienen un comportamiento análogo, en cuanto a los operandos, ya que admiten enteros y de coma flotante. Sintaxis:
<expresión> + <expresión>
<expresión> - <expresión>
<expresión> * <expresión>
<expresión> / <expresión>
Evidentemente se trata de las conocidísimas operaciones aritméticas de suma, resta, multiplicación y división, que espero que ya domines a su nivel tradicional, es decir, sobre el papel.
El operador de módulo '%', devuelve el resto de la división entera del primer operando entre el segundo. Por esta razón no puede ser aplicado a operandos en coma flotante.
<expresión> % <expresión>
Nota: Esto quizás requiera una explicación:
Veamos, por ejemplo, la expresión 17 / 7, es decir 17 dividido entre 7. Cuando aprendimos a dividir, antes de que supiéramos sacar decimales, nos enseñaron que el resultado de esta operación era 2, y el resto 3, es decir 2*7+3 = 17.
En C y C++, cuando las expresiones que intervienen en una de estas operaciones sean enteras, el resultado también será entero, es decir, si 17 y 7 se almacenan en variables enteras, el resultado será entero, en este caso 2.
Por otro lado si las expresiones son en punto flotante, con decimales, el resultado será en punto flotante, es decir, 2.428571. En este caso: 7*2.428571=16.999997, o sea, que no hay resto, o es muy pequeño.
Por eso mismo, calcular el resto, usando el operador %, sólo tiene sentido si las expresiones implicadas son enteras, ya que en caso contrario se calcularán tantos decimales como permita la precisión de tipo utilizado.
Siguiendo con el ejemplo, la expresión 17 % 7 dará como resultado 3, que es el resto de la división entera de 17 dividido entre 7.
Por último otros dos operadores unitarios. Se trata de operadores un tanto especiales, ya que sólo pueden trabajar sobre variables, pues implican una asignación. Se trata de los operadores '++' y '--'. El primero incrementa el valor del operando y el segundo lo decrementa, ambos en una unidad. Existen dos modalidades, dependiendo de que se use el operador en la forma de prefijo o de sufijo. Sintaxis:
<variable> ++ (post-incremento)
++ <variable> (pre-incremento)
<variable>-- (post-decremento)
-- <variable> (pre-decremento)
En su forma de prefijo, el operador es aplicado antes de que se evalúe el resto de la expresión; en la forma de sufijo, se aplica después de que se evalúe el resto de la expresión. Veamos un ejemplo, en las siguientes expresiones "a" vale 100 y "b" vale 10:
c = a + ++b;
En este primer ejemplo primero se aplica el pre-incremento, y b valdrá 11 a continuación se evalúa la expresión "a+b", que dará como resultado 111, y por último se asignará este valor a c, que valdrá 111.
c = a + b++;
En este segundo ejemplo primero se avalúa la expresión "a+b", que dará como resultado 110, y se asignará este valor a c, que valdrá 110. Finalmente se aplica en post-incremento, y b valdrá 11.
Los operadores unitarios sufijos (post-incremento y post-decremento) se evalúan después de que se han evaluado el resto de las expresiones. En el primer ejemplo primero se evalúa ++b, después a+b y finalmente c =<resultado>. En el segundo ejemplo, primero se evalúa a+b, después c = <resultado> y finalmente b++.
Es muy importante no pensar o resolver las expresiones C como ecuaciones matemáticas, NO SON EXPRESIONES MATEMATICAS. No veas estas expresiones como ecuaciones, NO SON ECUACIONES. Esto es algo que se tarda en comprender al principio, y que después aprendes y dominas hasta el punto que no te das cuenta.
Por ejemplo, piensa en esta expresión:
b = b + 1;
Supongamos que inicialmente "b" vale 10, esta expresión asignará a "b" el valor 11. Veremos el operador "=" más adelante, pero por ahora no lo confundas con una igualdad matemática. En matemáticas la expresión anterior no tiene sentido, en programación sí lo tiene.
La primera expresión equivale a:
b = b+1;
c = a + b;
La segunda expresión equivale a:
c = a + b;
b = b+1;
Esto también proporciona una explicación de por qué la versión mejorada del lenguaje C se llama C++, es simplemente el C mejorado o incrementado. Y ya que estamos, el lenguaje C se llama así porque las personas que lo desarrollaron crearon dos prototipos de lenguajes de programación con anterioridad a los que llamaron B y BCPL.
Operadores de asignación
Existen varios operadores de asignación, el más evidente y el más usado es el "=", pero no es el único.
Aquí hay una lista: "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", " ^=" y "|=". Y la sintaxis es:
<variable> <operador de asignación> <expresión>
En general, para todos los operadores mixtos la expresión
E1 op= E2
Tiene el mismo efecto que la expresión
E1 = E1 op E2
El funcionamiento es siempre el mismo, primero se evalúa la expresión de la derecha, se aplica el operador mixto, si existe y se asigna el valor obtenido a la variable de la izquierda.
Operador coma
La coma tiene una doble función, por una parte separa elementos de una lista de argumentos de una función. Por otra, puede ser usado como separador en expresiones "de coma". Ambas funciones pueden ser mezcladas, pero hay que añadir paréntesis para resolver las ambigüedades. Sintaxis:
E1, E2, ..., En
En una expresión "de coma", cada operando es evaluado como una expresión, pero los resultados obtenidos anteriormente se tienen en cuenta en las subsiguientes evaluaciones. Por ejemplo:
func(i, (j = 1, j + 4), k);
Llamará a la función con tres argumentos: (i, 5, k). La expresión de coma (j = 1, j+4), se evalúa de izquierda a derecha, y el resultado se pasará como argumento a la función.
Operadores de igualdad
Los operadores de igualdad son "==", (dos signos = seguidos) y "!=", que comprueban la igualdad o desigualdad entre dos valores aritméticos. Sintaxis:
<expresión1> == <expresión2>
<expresión1> != <expresión2>
Se trata de operadores de expresiones lógicas, es decir, el resultado es "true" o "false". En el primer caso, si las expresiones 1 y 2 son iguales el resultado es "true", en el segundo, si las expresiones son diferentes, el resultado es "true".
Expresiones con operadores de igualdad
Cuando se hacen comparaciones entre una constante y una variable, es recomendable poner en primer lugar la constante, por ejemplo:
if(123 == a) ...
if(a == 123) ...
Si nos equivocamos al escribir estas expresiones, y ponemos sólo un signo '=', en el primer caso obtendremos un error del compilador, ya que estaremos intentando cambiar el valor de una constante, lo cual no es posible. En el segundo caso, el valor de la variable cambia, y además el resultado de evaluar la expresión no dependerá de una comparación, sino de una asignación, y siempre será "true", salvo que el valor asignado sea 0.
Por ejemplo:
if(a = 0) ... // siempre será "false"
if(a = 123)...
// siempre será "true", ya que 123 es distinto de 0
El resultado de evaluar la expresión no depende de "a" en ninguno de los dos casos, como puedes ver.
En estos casos, el compilador, en el mejor de los casos, nos dará un "warning", o sea un aviso, pero compilará el programa.
Nota: los compiladores clasifican los errores en dos tipos, dependiendo de lo serios que sean:
"Errores": son errores que impiden que el programa pueda ejecutarse, los programas con "errores" no pueden pasar de la fase de compilación a la de enlazado, que es la fase en que se obtiene el programa ejecutable.
"Warnings": son errores de poca entidad, (según el compilador que, por supuesto, no tiene ni idea de lo que intentamos hacer). Estos errores no impiden pasar a la fase de enlazado, y por lo tanto es posible ejecutarlos. Debes tener cuidado si tu compilador de da una lista de "warnings", eso significa que has cometido algún error, en cualquier caso repasa esta lista e intenta corregir los "warnings".
Operadores lógicos
Los operadores "&&", "||" y "!" relacionan expresiones lógicas, formando a su vez nuevas expresiones lógicas. Sintaxis:
<expresión1> && <expresión2>
<expresión1> || <expresión2>
!<expresión>
El operador "&&" equivale al "AND" o "Y"; devuelve "true" sólo si las dos expresiones evaluadas son "true" o distintas de cero, en caso contrario devuelve "false" o cero. Si la primera expresión evaluada es "false", la segunda no se evalúa.
Generalizando, con expresiones AND con más de dos expresiones, la primera expresión falsa interrumpe el proceso e impide que se continúe la evaluación del resto de las expresiones. Esto es lo que se conoce como "cortocircuito", y es muy importante, como veremos posteriormente.
A continuación se muestra la tabla de verdad del operador &&:
|
Expresión1
|
Expresión2
|
Expresión1 && Expresión2
|
|
false
|
ignorada
|
false
|
|
true
|
false
|
false
|
|
true
|
true
|
true
|
El operador "||" equivale al "OR" u "O inclusivo"; devuelve "true" si cualquiera de las expresiones evaluadas es "true" o distinta de cero, en caso contrario devuelve "false" o cero. Si la primera expresión evaluada es "true", la segunda no se evalúa.
|
Expresión1
|
Expresión2
|
Expresión1 || Expresión2
|
|
false
|
false
|
false
|
|
false
|
true
|
true
|
|
true
|
ignorada
|
true
|
El operador "!" es equivalente al "NOT", o "NO", y devuelve "true" sólo si la expresión evaluada es "false" o cero, en caso contrario devuelve "false".
La expresión "!E" es equivalente a (0 == E).
|
Expresión
|
!Expresión
|
|
false
|
true
|
|
true
|
false
|
Operadores relacionales
Los operadores son "<", ">", "<=" y ">=", que comprueban relaciones de igualdad o desigualdad entre dos valores aritméticos. Sintaxis:
<expresión1> > <expresión2>
<expresión1> < <expresión2>
<expresión1> <= <expresión2>
<expresión1> >= <expresión2>
Si el resultado de la comparación resulta ser verdadero, se retorna "true", en caso contrario "false". El significado de cada operador es evidente:
> mayor que
< menor que
>= mayor o igual que
<= menor o igual que
En la expresión "E1 <operador> E2", los operandos tienen algunas restricciones, pero de momento nos conformaremos con que E1 y E2 sean de tipo aritmético. El resto de las restricciones las veremos cuando conozcamos los punteros y los objetos.
Operador "sizeof"
Este operador tiene dos usos diferentes.
Sintaxis:
sizeof (<expresión>)
sizeof (nombre_de_tipo)
En ambos casos el resultado es una constante entera que da el tamaño en bytes del espacio de memoria usada por el operando, que es determinado por su tipo. El espacio reservado por cada tipo depende de la plataforma.
En el primer caso, el tipo del operando es determinado sin evaluar la expresión, y por lo tanto sin efectos secundarios. Si el operando es de tipo "char", el resultado es 1.
A pesar de su apariencia, sizeof() NO es una función, sino un OPERADOR.
Asociación de operadores binarios
Cuando decimos que un operador es binario no quiere decir que sólo se pueda usar con dos operandos, sino que afecta a dos operandos. Por ejemplo, la línea:
A = 1 + 2 + 3 - 4;
Es perfectamente legal, pero la operación se evaluará tomando los operandos dos a dos y empezando por la izquierda, y el resultado será 2. Además hay que mencionar el hecho de que los operadores tienen diferentes pesos, es decir, se aplican unos antes que otros, al igual que hacemos nosotros, por ejemplo:
A = 4 + 4 / 4;
Dará como resultado 5 y no 2, ya que la operación de división tiene prioridad sobre la suma. Esta propiedad de los operadores es conocida como precedencia. En el capítulo de operadores II se verán las precedencias de cada operador, y cómo se aplican y se eluden estas precedencias.
Del mismo modo, el operador de asignación también se puede asociar:
A = B = C = D = 0;
Este tipo de expresiones es muy frecuente en C y C++ para asignar el mismo valor a varias variables, en este caso, todas las variables: A, B, C y D recibirán el valor 0.
