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
|
good
ResponderEliminar