Operadores C++

Operadores aritméticos.
+                 Suma
-                  Resta
*                 Multiplicación
/                 División
%                Módulo ó resto de la división entera
En C++ no hay operador de potenciación. Esta operación se realiza con la función pow.
El operador % obtiene el resto de la división entre enteros. Requiere que los operandos sean enteros y el segundo operando no sea nulo. Cuando se aplica el operador % a operandos de distinto signo, la mayoría de las versiones de C++ asignan al resultado el signo del primer operando.
El operador / requiere que el segundo operando no sea nulo. Si los dos operandos son enteros se obtiene como resultado la parte entera (cociente truncado, sin decimales).
Ejemplo de operaciones:
int a = 10, b = 3;
double v1 = 12.5, v2 = 2.0;
char c1='P', c2='T'; //Según la tabla ASCII ‘P’=80 ‘T’=84 ‘5’=53
Expresión
Valor
Expresión
Valor
Expresión
Valor
a+b
13
v1+v2
14.5
c1
80
a-b
7
v1-v2
10.5
c1 + c2
164
a*b
30
v1*v2
25.0
c1 + c2 + 5
169
a/b
3
v1/v2
6.25
c1 + c2 + ‘5’
217
a%b
1




En aquellas expresiones en las que aparecen operandos de distinto tipo, C++ convierte los valores al tipo de dato de mayor precisión de todos los datos que intervienen. Esta conversión es de forma temporal, solamente para realizar la operación. Los tipos de datos originales permanecen igual después de la operación.
Por ejemplo:
int n = 10;
double v1 = 12.5, v2;
v2 = n + v1;  // da como resultado 22.5
para realizar esta operación se convierte el valor de n a tipo double que es el tipo de v1. Realmente n no se modifica, solo su valor es convertido para realizar la suma.
Más ejemplos:
int i = 7;
double f = 5.5;
char c = 'w';  // ASCII ‘w’=119 ‘0’=48

Expresión
Valor
Tipo
i + f
12.5
double
i + c
126
int
i + c – ‘0’
78
int
(i + c) – (2 * f / 5)
123.8
double
En ocasiones resulta útil convertir el valor de una expresión a un tipo de datos diferente: esto se conoce como casting o conversión de tipos que veremos más adelante.
En las expresiones en las que aparecen varios operadores aritméticos, el orden de ejecución es siempre de mayor a menor prioridad y dentro de la misma prioridad de izquierda a derecha. Los operadores *, / y % tienen entre ellos la misma prioridad, siendo mayor que la de + y –, que también tienen entre ellos la misma prioridad. (Ver tabla al final de la entrada)
Operadores unitarios.
       +                signos negativo y positivo
++    --                 incremento  y decremento
~ ó compl             Complemento a 1    
Estos operadores afectan a un solo operando.
El operador incremento ++ incrementa en 1 el valor de la variable.
Ejemplo:
int i = 1;
i++;   // Esta instrucción incrementa en 1 la variable i.
         // Es lo mismo que hacer i = i + 1; i toma el valor 2
El operador decremento –- decrementa en 1 el valor de la variable.
Ejemplo:
int i = 1;
i--;    // decrementa en 1 la variable i. 
        // Es lo mismo que hacer i = i - 1; i toma el valor 0
Los operadores incremento y decremento pueden utilizarse como prefijo o sufijo, es decir, pueden aparecer antes o después de la variable.
Por ejemplo:
i = 5;
i++; // i vale ahora 6
++i; // i vale ahora 7
Cuando estos operadores intervienen en una expresión, si preceden al operando (++i), el valor se modificará antes de que se evalúe la expresión a la que pertenece.
En cambio, si el operador sigue al operando (i++), entonces el valor del operando se modificará después de evaluar la expresión a la que pertenece.
Por ejemplo:
int x, i = 3;
x = i++;
En esta asignación a x se le asigna el valor 3 y a continuación i se incrementa, por lo tanto, después de ejecutarla: x contiene 3, i contiene 4.
Si las instrucciones son:
int x, i = 3;
x = ++i;
En esta instrucción primero se incrementa i y el resultado se asigna a x. Por lo tanto, después de ejecutarla: x contiene 4, i contiene 4.

Otro ejemplo:
int i = 1;
cout << i << “ “;
cout << ++i << “ “;
cout << i << “ “;
Estas instrucciones mostrarán por pantalla:
1 2 2
En cambio, si se cambia la posición del operador:
int i = 1;
cout << i << endl;
cout << i++ << endl;
cout << i << endl;
Estas instrucciones mostrarán por pantalla:
1
1
2
El operador complemento a 1 ~ cambia de valor todos los bits del operando (cambia unos por ceros y ceros por unos). Solo puede usarse con datos de tipo entero.
Puede usarse el carácter ~ (ASCII 126) ó el operador equivalente compl.
Por ejemplo:
int a = 1, b = 0, c = 0;
c = ~a;
b = compl a;
Operadores relacionales y lógicos.
Los operadores relacionales comparan dos operandos y dan como resultado de la comparación verdadero  ó falso.
Los operadores relacionales en C++ son:
<                          Menor que
>                          Mayor que
<=                        Menor o igual
>=                        Mayor o igual
!= ó not_eq            Distinto
==                        Igual
Los operadores lógicos se utilizan con operandos de tipo lógico y dan como resultado verdadero o falso.
Los operadores lógicos en C++ son: 
&& ó and     El resultado es verdadero si los dos operandos son verdaderos. El resultado el falso en caso contrario. Si el primer operando es falso no se evalúa el segundo, ya que el resultado será falso.
|| ó or       El resultado es falso si los dos operandos son falsos. Si uno es verdadero el resultado es verdadero. Si el primer operando es verdadero no se evalúa el segundo.
! ó not        Se aplica sobre un solo operando. Cambia el valor del operando de verdadero a falso y viceversa.

Los operadores relacionales se utilizan para construir expresiones lógicas, cuyo resultado es de tipo cierto o falso.
En C++ toda expresión numérica con un valor distinto de cero (no sólo el 1) se considera como cierta y el valor cero como falsa.
Por ejemplo, en la siguiente tabla vemos una serie de expresiones lógicas y su valor:
int i = 7;
float f = 5.5F;
char c = ‘w’;
         Expresión
Resultado
(i >= 6) && (c == ‘w’)
Cierto
(i >= 6) || (c == 119)
Cierto
(f < 11) and (i > 100)
Falso
(c != ‘p’) or ((i + f) <= 10)
Cierto
i + f <= 10
Falso
i >= 6 && c == ‘w’
Cierto
c != ‘p’ || i + f <= 10
Cierto

Las expresiones lógicas compuestas que constan de expresiones lógicas individuales unidas por los operadores lógicos && y || se evalúan sólo hasta que se ha establecido el valor cierto o falso del conjunto.
Cuando, por ejemplo, una expresión va a ser seguro falsa por el valor que ha tomado uno de sus operandos, C++ ya no evalúa el resto de expresión.
Operadores a nivel de bits
Operan con datos de tipo entero. Realizan con sus operandos las operaciones lógicas and, or, xor y desplazamiento bit a bit.
Los operadores a nivel de bits en C++ son:
& ó bitand     and a nivel de bits
| ó bitor        or a nivel de bits
^ ó xor         xor a nivel de bits
<<               desplazamiento a la izquierda, rellenando con ceros a la derecha
>>             desplazamiento a la derecha, rellenando con el bit de signo por la izquierda
Por ejemplo:
int a = 11, b = 7, c;
c = a & b;      // 11 & 7, en binario: 1011 and 0111 = 0011 que es el 3 en decimal
cout << c << endl;   // muestra 3 
c = a | b;
cout << c << endl;   // muestra 15
c = a ^ b;
cout << c << endl;   // muestra 12
c = b << 1;
cout << c << endl;   // muestra 14. Equivale a b * 2
c = b >> 1;
cout << c << endl;   // muestra 3. Equivale a 3 / 2

Operadores de asignación.
Se utilizan para asignar el valor de una expresión a una variable.
=                          Asignación
+=                       Suma y asignación
– =                       Resta y asignación
*=                        Producto y asignación
/=                        División y asignación
%=                       Resto de la división entera y asignación
<<=                      Desplazamiento a la izquierda y asignación
>>=                      Desplazamiento a la derecha y asignación
&= ó and_eq           and sobre bits y asignación
|= ó or_eq             or sobre bits y asignación
^= ó xor_eq           xor sobre bits y asignación
Si los dos operandos de una expresión de asignación son de distinto tipo, el valor de la expresión de la derecha se convertirá al tipo del operando de la izquierda.
Por ejemplo, una expresión de tipo real (float, double) se truncará si se asigna a un entero, o una expresión de tipo double se redondeará si se asigna a una variable de tipo float.
En C++ están permitidas las asignaciones múltiples.
Ejemplo:       a = b = c = 3;                  equivale a     a = 3; b = 3; c = 3;
Ejemplo de asignaciones:
a += 3;                           equivale a     a = a + 3;
a *= 3;                           equivale a     a = a * 3;
En general:
variable op= expresión   equivale a:   variable = variable op expresión
En la siguiente tabla vemos más ejemplos de asignaciones:
int i = 5, j = 7, x = 2, y = 2, z = 2;
float f = 5.5F, g = -3.25F;
Expresión
Expresión equivalente
Valor final
i += 5
i = i + 5
10
f –= g
f = f – g
8.75
j *= (i – 3)
j = j * (i – 3)
14
f /= 3
f = f / 3
1.833333
i %= (j - 2)
i = i % (j – 2)
0
x *= -2 * (y + z) / 3
x = x * (-2 * (y + z) / 3)
-4

Operador condicional.
Lo forman los caracteres  ?  y : 
Se utiliza de la forma siguiente:
expresión1 ? expresión2 : expresión3
Si expresión1 es cierta entonces se evalúa expresión2 y éste será el valor de la expresión condicional. Si expresión1 falsa, se evalúa expresión3 y éste será el valor de la expresión condicional.
Por ejemplo:
int i = 10, j;
j = (i < 0) ? 0 : 100;
Esta expresión asigna a j el valor 100. Su significado es: si el valor de i es menor que 0 asigna a j el valor 0, sino asigna a j el valor 100. Como i vale 10, a j se le asigna 100.
La instrucción anterior es equivalente a escribir:
if(i < 0)
   j = 0;
else
   j = 100;

Más Ejemplos de operador condicional en C++:  
int a=1, b=2, c=3;
c+=(a>0 && a<= 10) ? ++a : a/b;  /* c toma el valor 5*/
int a=50, b=10, c=20;
c+=(a>0 && a<=10) ? ++a : a/b;  /* c toma el valor 25*/
Otros operadores
Operador coma
La coma, usada como operador, se utiliza para encadenar varias expresiones.
Ejemplo:       x=(v=3,v+5)
Equivale a:    v=3
                   x=v+5
Ejemplo:       z=26
           v=(z=z+10,72/z)
Equivale a:    z=26
           z=z+10
           v=72/z
Operador de dirección
Se representa por el símbolo & (ampersand), y su función es la de obtener la dirección dónde se almacena una determinada variable.
Por ejemplo, dadas las siguientes instrucciones:
int x = 10;
cout << “Valor de x: “ << x << endl;
cout << “Dirección de la variable x: “ << &x << endl;
muestran por pantalla:
Valor de x: 10
Dirección de la variable x: 0x27ff44
Operador de indirección
Se representa por un asterisco *,  y su función es la de obtener el valor contenido en una dirección de memoria.
Un puntero es una variable que contiene una dirección de memoria. Para definir una variable puntero se escribe: tipo *variable.
Por ejemplo: int *p;
En el siguiente ejemplo se declara un puntero y dos variables enteras y se utiliza el operador de indirección para obtener el valor contenido en una dirección de memoria.
int *p, x = 10, y = 0;  //se declara el puntero p y las variable x e y
p = &x;                 //a p se le asigna la dirección de memoria de x
y = *p;           //a y se le asigna el valor guardado en la dirección de memoria
que contiene p. Como p contiene la dirección de x, a y se le asigna el valor 10
Veremos los punteros en un tema posterior.
Operador referencia a
Una referencia es un nombre alternativo (un alias, un sinónimo) para un objeto.
La forma general de expresar una referencia es:
tipo &referencia = variable;
Por ejemplo:
float m = 30.01;
float &n = m; // n es una referencia de m
Se ha declarado la variable m como float y n como referencia de m, indicando al compilador que en este programa m también tiene otro nombre ( n ).
Las operaciones realizadas sobre m se reflejan en n, y viceversa. Por lo tanto en el programa podemos utilizar indistintamente m o n.
Una referencia no es una copia de la variable referenciada, sino que es la misma variable con un nombre diferente.
Los operadores no operan con la referencia sino directamente sobre la variable referenciada.
Por ejemplo:
int j = 0;
int &k = j; // k es una referencia a j;
k++;
cout << j << endl;   // muestra 1
cout << k << endl;   // muestra 1;
Una referencia debe ser inicializada y su valor no puede ser alterado después de haberla inicializado, por lo que siempre se referirá al mismo objeto.
Las referencias se utilizan, por ejemplo, como alternativa a los punteros en el paso de parámetros en las funciones.
Operador global y de resolución de ámbito
Es el operador :: y permite el acceso a una variable global que ha quedado oculta por una variable local.
En POO se usa para indicar a qué clase pertenece un determinado método.
Operador sizeof
Obtiene el tamaño en bytes de un tipo de datos o de una variable previamente declarada.
Por Ejemplo, las siguientes instrucciones:
double a;
cout << “Entero-> “ << sizeof(int) << endl;
cout << “Caracter-> “ << sizeof(char) << endl;
cout << “Double-> “ << sizeof(a) << endl;

Dan como resultado:
Entero-> 4
Caracter-> 1;
Double-> 8
El operador sizeof se puede utilizar con tipos primitivos y con tipos derivados.

Prioridad y orden de evaluación de los operadores en C++
La siguiente tabla muestra todos los operadores de C++ ordenados de mayor a menor prioridad.
Los operadores que aparecen en la misma línea tienen la misma prioridad.

::
Sin asociatividad
()   []   .    ->   n++   n--   _cast    typeid
Izquierda a Derecha
signo ~  !  *  &  ++n -–n   sizeof  new  delete   (tipo)
Derecha a Izquierda
->*        .*
Izquierda a Derecha
*    /    %
Izquierda a Derecha
+   -
Izquierda a Derecha
<<     >>
Izquierda a Derecha
<       <=        >       >=
Izquierda a Derecha
==     !=
Izquierda a Derecha
&
Izquierda a Derecha
^
Izquierda a Derecha
|
Izquierda a Derecha
&&
Izquierda a Derecha
| |
Izquierda a Derecha
? :
Derecha a Izquierda
=  +=  -=  *=   /=   %=   <<=   >>=   &=   |=   ^=
Derecha a Izquierda
,
Izquierda a Derecha


No hay comentarios:

Publicar un comentario en la entrada