Aprende a Programar: 3 - Tipos de datos

Como hemos dicho en el tema anterior, existen varios tipos de variables, cada uno es capaz de almacenar los valores de un dominio en concreto. En esta unidad didáctica veremos los tipos de datos básicos.

* Entero: int. Representa cantidades enteras (positivas o negativas), en memoria ocupa 2 bytes (16 bits).
* Carácter: char. Representa un caracter ASCII, el compilador lo trata como un entero de 8 bits.
* Cadena: string. No es un tipo básico (es derivado del char), pero es de gran utilidad. Representa una cadena de caracteres, incluidos espacios. El tamaño que ocupa en memoria es variable.
* Coma flotante: float. Para rangos numéricos mayores que el tipo entero, y además con parte fraccionaria. Ocupa cuatro bytes (32 bits).
* Coma flotante de doble precisión: double. Es como el float, pero con mayor precisión (almacena números más largos). Ocupa 8 bytes.
* Lógico: bool. Sólo toma los valores true y false. C++ tiene una peculiaridad, y es que toma el valor 0 como falso, y cualquier otro como verdader.
* Vacío: void. Este tipo lo usaremos en el tema de las funciones.

Es importante distinguir entre los distintos tipos de datos. Una de las cuestiones que le cuesta entender a los que se inician en la programación, es la diferencia entre el caracter '5', y el número 5. Son dos tipos de datos distintos. Nosotros tenemos asociado el caracter '5' con el valor cinco, pero son cosas diferentes, uno es el signo y el otro es el significado. Es evidente que necesitemos un signo para representar ese significado, para representar el valor 5 usamos el símbolo '5'. Así que cuando necesitemos que nuestro programa tenga que mostrar un mensaje en pantalla indicando una cifra numérica, esta será representada por sus caracteres correspondientes, pero cuando necesitemos que el programa opere con una cantidad numérica, indicaremos el valor correspondiente, mediante números.
El compilador trata a una variable de tipo char o string como caracteres, de forma que si a una variable de estos tipos le asignas el caracter '5', el compilador la trata como una tecla de tu teclado simplemente, no como el valor 5. Más adelante veremos la conversión de tipos, de forma que es posible convertir variables de un tipo en otro.

OPERADORES

Un operador es un símbolo que nos permite realizar operaciones sobre los datos, que serán los operandos.

OPERADOR ASIGNACIÓN

Usamos el operador asignación para almacenar datos en nuestras variables, de la siguiente forma: nombreVariable=expresion;. La asignación se efectúa de derecha a izquierda, evaluando la expresión y asignando su valor al identificador de la variable.
Si los tipos de la expresión y de la variable no coinciden, el compilador genera un cambio automático de tipo de la expresión, al tipo de la variable.
Ejemplos: a=b+2; c=3*6; m=7;
C++ permite realizar varias asignaciones en la misma sentencia, de forma que las asignaciones se efectúan de derecha a izquierda (realizando las conversiones de tipo necesarias, como se ha indicado antes).
Ejemplo:

int a;
float x,y;
x=a=y=3.5;

Ahora analicemos lo que ha pasado: primero se ha asignado el valor 3.5 a la variable y. Luego se asigna el valor de y (3.5) a la varible a, pero, ¡atención!, a es de tipo int, por tanto el compilador hace una conversión de tipos, convierte el valor 3.5 en un valor entero, 3. Por tanto ahora a vale 3, y a x se le asigna el valor de a, 3.0. Por tanto al final queda:
y=3.5, a=3, x=3.0

Tenemos variantes del operador asignación que nos serán útiles para ahorrar tiempo y espacio. Veamos unos ejemplos:

x+=10; equivale a x=x+10;
x-=10; equivale a x=x-10;
Lo mismo ocurre con *= /= %=

OPERADORES ARITMÉTICOS

Sirven para realizar operaciones matemáticas entre los datos.
Existen operadores binarios (actúan sobre dos objetos) y monarios (sobre un objeto).

Binarios:

* + suma
* - resta
* * multiplicación
* / división
* % resto de la división entera

Hay que resaltar que el operador / devuelve un resultado entero en caso de que los operandos sean del tipo int.
Ejemplo:

int a;
float x;
a=7/5; //a vale 1
x=7.0/5; //x vale 1.4

Monarios:

* ++ Incrementa la variable en una unidad.
* -- Decrementa la variable en una unidad.

Los operadores de incremento y decremento se pueden usar a la derecha o a la izquierda de la variable (a++; o ++a;). Pero hay que tener en cuenta que si el operador se usa a la izquierda, la variable se incrementa o decrementa antes de utilizarla. Mientras que el si el operador se usa a la derecha, la variable cambia su valor después de usarla.
Ejemplo:

int x,n;
x=5;
n=++x; //n=6 y x=6
n=x++; //Después de esta asignación x valdrá 7 pero n sigue valiendo 6

Es IMPORTANTE señalar que cuanto se declara una variable no tiene un valor asignado, y por tanto sería un error realizar un incremento o decremento sobre una de estas variables, ya que no contiene ningun valor para incrementar o decrementar. Antes de aplicar un operador monario habría que inicializar la variable (darle algún valor).

OPERADORES RELACIONALES

Sirven para comparar los valores de dos expresiones y devuelven uno de los dos valores posibles: true o false.

* < Menor que
* > Mayor que
* <= Menor o igual
* >= Mayor o igual
* == Igual que
* != Distinto de

Uno de los errores más comunes es C++, es confundir el operador '=' con el operador '==', de forma que a veces se llega a resultados erróneos.
Por ejemplo:

int a=3;
a==3 //Devuelve verdadero (true)
a<10 //Devuelve verdadero
a>5 //Devuelve falso
a<=2 //Devuelve falso
a>=3 //Devuelve verdadero
a=5 //¿Qué crees que devolverá?

Pues devuelve VERDADERO, porque no estamos comparando si a es igual a 5, sino que estamos asignando 5 a la variable a, por tanto la expresión vale 5, y como hemos dicho, ¡¡en C++ lo que no es 0 es verdadero!!.

OPERADORES LÓGICOS

Permiten interconectar expresiones relacionales:

* && "y"
* || "o"
* ! "no"

Supngo que sabes algo de lógica, pero por sea caso vamos aponer unos ejemplos:
bool cierto=true,falso=false;
int n=3;
string cadena="hola";

cierto && cierto //Devuelve true
cierto && falso //Devuelve false
cierto || falso //true
(cierto || falso) && falso //false
cierto || (falso && falso) //true
!cierto //true
!cierto && !falso //falso
!cierto && cierto //falso
!cierto || !falso //true
!falso && cierto //true
!(cierto && falso) //true
n==3 && n<10 //true
n==3 && n<2 //false
n<3 || n==3 //true
n!=10 || n==20//true

CONVERSIÓN DE TIPOS

A veces nos interesa que una variable o expresión se comporte como si fuese de un tipo distinto al que es. Esto se puede conseguir colcando entre paréntesis el tipo de dato deseado delaten de la variable o expresión. Esto se llama conversión de tipo o cast.
El cambio afecta al valor resultante, pero no afecta a los datos en si.
Ejemplo:

int a,b;
float d;
a=7;
b=5;
d=a/b; //d vale 1
d=(float)a/b //d=1.4 y a sigue siendo entero
a=(int)d; //a=1 y d=1.4