Manual de Programación en C: Operadores sobre variables.


En este capítulo aprenderemos las operaciones que se pueden llevar a cabo con las variables. Por operaciones entendemos manipulación de datos, siempre que una variable cambie, habrá habido una operación, las clasificamos en:

  • De asignación
  • Aritméticos
  • Lógicos
  • A nivel de bits

Los nombres tampoco importan mucho, porque a la hora de usarlos simplemente usarás el que necesites, de hecho yo tuve que buscar los nombre y tipos porque no los recordaba.

De asignación

Estos ya los vimos en la última entrega, cuando vimos cómo definir y dar valor a las variables. El único operador de este tipo es el signo “=”.

Se usa así:

valor1 = valor2;

valor1 valdrá lo que valga valor2, valor1 es una variable y valor2 puede ser tanto una variable como un número que escribamos nosotros, tal y como vimos en la anterior entrega.

También podemos darle valor a varias variables a la vez.

var1 = var2 = 3;

O darle a varias variables el valor de otra:

var1 = var2 = var3;

Aquí hay que decir que se lee de derecha a izquierda, si var1 = 0, var2 = 0 y var3 = 1, hay quien podría pensar que var1 = var2, y luego var2 = var3, es decir que al final var1=0 y var2 y var3 valen 1. Pues no, todas las variables valdrían 1.

Aritméticos

Estos son los de suma, resta, multiplicación, división, incremento, decremento y resto. Para operaciones más complejas como raíces, potencias, etc, hay librerías con funciones que las hacen, las veremos en próximos capítulos.

1.-Suma

Se usa el símbolo “+”.

var1 = var2 + var3;

var2 y var3 pueden ser números o variables.

var1 = var2 + 5;

2.- Resta
Se usa el símbolo “-“.

var1 = var2 – var3;

3.- Multiplicación
Se usa el asterisco “*”.

var1 = var2 * var3;

4.- División
Se usa la barra “/”.

var1 = var2 / var3;

5.- Incremento
Se usan dos símbolos de suma “++”. Lo que hace es sumarle 1 a la variable.

var1++; //Es equivalente a poner var1 = var1 + 1;

6.- Decremento
Igual que el incremento pero con dos símbolos de resta “–“. Le resta uno a la variable.

var1–; //Equivalente a poner var1 = var1 – 1;

7.- Resto
Calcula el resto de una división. Se usa el símbolo “%”.

var1 = 7%2; //var1 valdrá 1, el resto de la división.

Comparaciones

Estos operadores nos permitirán comparar distintas variables, ¿recuerdas que las funciones podían dar valores de salida? Este venía dado por el tipo de dato de la salida de la función, si era int nos daría un número entero, si era char nos daría una letra, etc. Las comparaciones funcionan de forma similar, también nos dan una salida, pero esta es siempre un entero, y será 1 ó 0, podemos ver como si el 1 valiera lo mismo que la palabra Sí y el 0 valiera lo mismo que la palabra No. Cuando una comparación se cumple, entonces da un 1 (sería como sustituirla por un 1) y si no se cumple dará un cero.

Vamos a ver cómo es esto con el primer tipo de comparaciones:

1.- Igual que (==)

El símbolo son dos iguales “==” con una variable a cada lado, las compara, si las variables valen lo mismo nos dará un 1, si no, nos dará un 0. Por ejemplo

int var1 = 5;
int var2 = 5;
printf(“Resultado: %i\n”, var1==var2);

Como son iguales, veremos por pantalla

Resultado: 1

Si no lo fueran habría un 0. La comparación se puede hacer entre cualquier tipo de dato: int, char, double, float, etc.

2.-Resto de comparadores.
Aquí tienes una tabla con el resto de comparadores y su símbolo.

== igual que se cumple si son iguales
!= distinto que se cumple si son diferentes
> mayor que se cumple si el primero es mayor que el segundo
< menor que se cumple si el primero es menor que el segundo
>= mayor o igual que se cumple si el primero es mayor o igual que el segundo
<= menor o igual que se cumple si el primero es menor o igual que el segundo

Aquí tienes un código en el que usan todos.


#include
int main()
{
int var1 = 5;
int var2 = -3;
printf(“Iguales: %i\n”, var1 == var2);
printf(“Diferentes: %i\n”, var1 != var2);
printf(“var1 mayor que var2: %i\n”, var1 > var2);
printf(“var1 menor que var2: %i\n”, var1 < var2);
printf(“var1 mayor o igual que var2: %i\n”, var1 >= var2);
printf(“var1 menor o igual que var2: %i\n”, var1 <= var2);
return 0;
}

Y el resultado que queda así:

Iguales: 0
Diferentes: 1
var1 mayor que var2: 1
var1 menor que var2: 0
var1 mayor o igual que var2: 1
var1 menor o igual que var2: 0

Operadores lógicos.

Estos nos permiten unir unas comparaciones con otras, por ejemplo, si queremos saber si dos números son iguales y si ambos son mayores de 0 (bastaría con comprobar uno, porque el otro al ser igual también sería mayor de 0)

int var1 = 5;
int var2 = 5;
printf(“Iguales y mayores de 0: %i\n”, var1==var2 && var1 > 0);

El resultado sería:

Iguales y mayores de 0: 1

Los operadores lógicos son:
&& -> equivalente al and (y) si se cumple una y otra comparación.
|| -> equivalente al or (o) si se cumple una u otra comparación.
! -> NOT (no) invierte el valor de la condición, un ejemplo es el != (si no es igual) que hemos visto en comparaciones.

Operaciones a nivel de bits

Como vimos en anteriores entregas, la menor cantidad de memoria es un bit, que puede valer 1 ó 0.
Estos operadores transformarán datos dependiendo de los bits
Los operadores que tenemos son:
& -> (and) el resultado es 1 si son iguales: 0 & 0 = 1, 1 & 1 = 1, 0 & 1 = 0;
Si aplicamos la operación & a estas cadenas
1001010
0110001 nos queda:
0000100
| -> (or) el resultado es 1 si son distintos o son 1 y 1 y 0 si son 0 y 0: 1 | 0 = 1, 1 | 1 = 1, 0 | 0 = 0;
Si aplicamos la operación | a estas cadenas
1101001
1110010 nos queda
1111011
^ -> (xor) eXclusive OR, el resultado es 1 si son distintos y 0 si son iguales.
Si aplicamos la operación ^ a estas cadenas
1010010
1011100 nos queda
0001110
~ -> complemento a 1, este solamente admite un operador y lo que hace es invertir los bits
si aplicamos el operados ~ a la cadena
1101001 nos queda
1010110 el primer número queda igual y así tenemos números negativos en binario, el complemento a uno convierte un número en su negativo usando matemática binaria, si el primer bit es 1 entonces es negativo, si no, es positivo.
>> -> desplazamiento a la derecha
Desplaza los bits a la derecha el número de lugares que se indique, los de la izquierda se convierten en 0 y los de la derecha se pierden
si hacemos
210 >> 2
210 = 11010010
primera pasada -> 01101001
segunda pasada -> 00110100
210 >> 2 = 52
<< -> desplazamiento a la izquierda
Igual que el desplazamiento a la derecha pero en sentido contrario.

Ejemplos de operadores a nivel de bit.

printf(“Resultado: %i\n”, 253 | 32);

El resultado es:

Resultado: 253

Sigámolo por pasos.
253      =        11111101
32 =               01000000
253 | 32 =   11111101 = 253

Otros operadores

Todos estos operadores pueden asociarse por paréntesis para que se realicen de un determinado orden:

printf(“Resultado: %i\n”, ((5+3)*2)&35);

Esta es la jerarquía de operaciones, cuánto más arriba antes se ejecutarán:
() [] -> .
! ~ ++ — *(de puntero) & sizeof
*(de multiplicación) / %
+ –
<>
< >=
== !=
&
^
|
&&
||
?:
= += -= *= /=
,

Se que hay algunos que no hemos visto, como el -> y el * de puntero, ya los veremos en próximos capítulos, no se pueden explicar ahora.

Hasta aquí este capítulo, como siempre, para cualquier pregunta, duda, sugerencia, crítica, error. Comentad aquí o enviad un correo, página Contacto en el menú superior del blog.
Licencia de Creative Commons
Manual de C by The Neowriter is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

Anuncios
Esta entrada fue publicada en Manual de programación en C, Manuales, Manuales largos y etiquetada , , , , , , . Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s