Saltar a: navegación, buscar

Operadores

Operadores
Información sobre la plantilla
Concepto:Son un tipo de tokens que pueden aparecer en las expresiones, e indican al compilador la realización de determinadas operaciones matemáticas, lógicas y numéricas
Operadores. Son un tipo de tokens que pueden aparecer en las expresiones, e indican al compilador la realización de determinadas operaciones matemáticas, lógicas y numéricas. Se aplican a variables u otros objetos denominados operandos y su efecto es una combinación de las siguientes acciones:
  • Producir un resultado-valor
  • Alterar un operando
  • Designar un objeto o función.

Ejemplos

  • y = a + b;

En esta sentencia, el operador suma + produce un valor nuevo, pero no altera ninguno de los operandos (a y b); a su vez, el nuevo valor es asignado a la variable y mediante el operador de asignación =. En este caso el operando de la izquierda sí se ve alterado.

  • x++;

Aquí el operador postincremento ++ produce un nuevo valor que es aplicado sobre el propio operando, de forma que queda alterado. Cuando un operador altera un operando se dice que tiene efectos laterales.
Nota: por lo general, los operadores aparecen a la derecha de expresiones de asignación (por ejemplo: y = 2 * y + x), pero en ocasiones estos "efectos laterales" se utilizan para conseguir expresiones muy compactas y de un cierto nivel de sofisticación, que incluso no necesitan del operador de asignación para producir el resultado. En estos casos su lógica es un poco más difícil de seguir que cuando estos efectos no se utilizan directamente.

  • z = (*fptr)(x, y);

Aquí, el operador de indirección * es aplicado sobre el operando fptr que es un puntero-a-función. El resultado es un designador de función al que se aplica el operador ( ) de invocación de función con dos operandos x e y que actúan como argumentos. A su vez el resultado de este operador (invocación de función) es utilizado como argumento derecho del operador de asignación = que finalmente modifica uno de sus operandos (el operando izquierdo z)

Clasificación

Los operadores se pueden clasificar en unitarios, binarios y ternarios, según que necesiten uno, dos o tres operandos. Los operadores unitarios (denominados también unarios) se clasifican en dos tipos según la posición del operador (representado aquí por @) respecto del operando (representado aquí por n):
@n: Operador prefijo. Ejemplo: ++x
n@: Operador posfijo. Ejemplo: x++

Observaciones

  • Los operadores pueden (en cierta forma) considerarse como funciones que tienen un álgebra un tanto especial. De hecho, al tratar la sobrecarga de operadores, veremos que precisamente la forma en que se definen es mediante una función, la función-operador. En este sentido podríamos imaginar que la expresión y = a + b es otra forma de representar algo como: y = suma(a, b). Del mismo modo, la asignación x = y sería algo así: asigna(x, y). Siguiendo con nuestra analogía, podríamos suponer que los operadores unitarios, binarios y ternarios serían funciones que aceptarían unos, dos o tres argumentos respectivamente y que la sobrecarga de operadores no es sino una forma encubierta de sobrecarga de funciones.
  • Aunque las funciones C++ se designan con identificadores (nombres) que siguen las reglas generales ya señaladas, estas seudo-funciones se identifican con símbolos (+,=, ::,*,->,etc). Muchos de ellos están compuesto de un solo token (que puede estar repetido + y ++) aunque los hay de dos. Estos últimos son: new[], delete[], () y [].
  • Antes de realizar la operación encomendada, los operadores pueden modificar el tipo de los operandos para que sean homogéneos, de forma que la operación pueda realizarse. Por ejemplo, al indicar i + f donde i sea un entero y f un float. Estas promociones se denominan conversiones estándar y son realizadas automáticamente por el compilador, pero deben ser tenidas en cuenta para evitar sorpresas.

En general los operadores aceptan un tipo de operando determinado y específico, produciendo y/o modificando un valor de acuerdo con ciertas reglas, pero C++ permite redefinir la mayoría de ellos. Es decir, permite que puedan aceptar otro tipo de operandos y seguir otro comportamiento sin que pierdan el sentido y comportamiento originales cuando se usan con los operandos normales (los tipos básicos preconstruidos en el lenguaje). Esta circunstancia recibe el nombre de sobrecarga del operador.
No son sobrecargables los siguientes:

  • ( . ) Operador de selección de miembros
  • ( .* ) Operador de dereferencia
  • ( :: ) Operador de acceso a ámbito
  • ( ?: ) Operador conditional
  • ( # ) Directiva de preprocesado

Polimorfismo en los operadores

Sin estar sobrecargado, dependiendo del contexto (número y tipo de operandos), un operador C++ puede tener más de un significado. Ejemplos:
El símbolo ámpersand & puede ser interpretado como:

  • AND entre bits A & B
  • Operador de referencia y = &x
  • Declarador de referencia int& y = x

El asterisco * puede ser interpretado como:

  • Declaración de un tipo puntero-a tipo* ptr
  • Operador de indirección x = *ptr
  • Operador de multiplicación x * y

Precedencia

La precedencia es una regla de orden que se asocia con los operadores para establecer cual se aplicará primero en caso de aparecer varios en una misma expresión (una especie de "orden de importancia" de los operadores). Por ejemplo:
x = 2 + 3 * 4;
¿Cual será el resultado, 20 o 14?

La primera regla en este sentido es que las expresiones se evalúan de izquierda a derecha, aunque no siempre. Por ejemplo, la regla izquierda → derecha nos conduciría a que en la expresión anterior, el valor de x es 20, lo cual no es cierto, ya que en C++ la multiplicación tiene mayor precedencia que la suma, así que el resultado es 14.
En C++ existen 16 niveles de precedencia, de modo que la regla izquierda → derecha solo se aplica en caso de operadores del mismo nivel
El operador de jerarquía más alta es el paréntesis, lo que aclara y justificada la tradicional costumbre algabráica de utilizar paréntesis para forzar el orden de las operaciones. Por ejemplo, si queremos que en la expresión anterior se ejecute primero el operador suma:
x = (2 + 3) * 4; // el resultado es 20
Aunque las reglas de precedencia se suponen conocidas por los programadores C++, aconsejamos generosidad a la hora de utilizar paréntesis en las expresiones. Además de facilitar la legibilidad evitan posibles errores. Así, aunque las dos sentencias que siguen son equivalentes, la segunda es de lectura más "relajante".
x = 2 + 3 * 4;
x = 2 + (3 * 4);

Véase también

Fuente