Variables En C++

Tipos de datos

Para declarar una variable ponemos el nombre del tipo seguido del de la variable. Podemos declarar varias variables de un mismo tipo poniendo el nombre del tipo y las variables a declarar separadas por comas:

int i, j, k;

Además podemos inicializar una variable a un valor en el momento de su declaración:

int i=100;

Cada tipo definido en el lenguaje (o definido por el usuario) tiene un nombre sobre el que se pueden emplear dos operadores:

Sizeof, que nos indica la memoria necesaria para almacenar un objeto del tipo, ynew, que reserva espacio para almacenar un valor del tipo en memoria.

Tipos elementales

El C++ tiene un conjunto de tipos elementales correspondientes a las unidades de almacenamiento típicas de un computador y a las distintas maneras de utilizarlos:

— enteros:

char

short int

int

long int

14

— reales (números en coma flotante):

float

double

long double

La diferencia entre los distintos tipos enteros (o entre los tipos reales) está en la memoria que ocupan las variables de ese tipo y en los rangos que pueden representar. A mayor tamaño, mayor cantidad de valores podemos representar. Con el operador sizeof podemos saber cuanto

ocupa cada tipo en memoria. Para especificar si los valores a los que se refieren tienen o no signo empleamos las palabras signed y unsigned delante del nombre del tipo (por ejemplo unsigned int para enteros sin

signo).Para tener una notación más compacta la palabra int se puede eliminar de un nombre de tipo demás de una palabra, por ejemplo short int se puede escribir como short, unsigned es equivalente a unsigned int, etc. El tipo entero char es el que se utiliza normalmente para almacenar y manipular caracteres en la mayoría de los computadores, generalmente ocupa 8 bits (1byte), y es el tipo que se utiliza como base para medir el tamaño de los demás tipos del C++.Un tipo especial del C++ es el denominado void (vacío). Este tipo tiene características muy peculiares, ya que es sintácticamente igual a los tipos elementales pero sólo se emplea junto alos derivados, es decir, no hay objetos del tipo void Se emplea para especificar que una función no devuelve nada o como base para punteros a objetos de tipo desconocido (esto lo veremos al estudiar los punteros). Por ejemplo: void BorraPantalla (void); indica que la función BorraPantalla no tiene parámetros y no retorna nada.

Tipos enumerados

Un tipo especial de tipos enteros son los tipos enumerados. Estos tipos sirven para definir un tipo que sólo puede tomar valores dentro de un conjunto limitado de valores. Estos valores tienen nombre, luego lo que hacemos es dar una lista de constantes asociadas a un tipo. La sintaxis es: en un booleano {FALSE, TRUE}; // definimos el tipo booleano

Aquí hemos definido el tipo booleano que puede tomar los valores FALSE o TRUE. En realidad hemos asociado la constante FALSE con el número 0, la constante TRUE con 1, y si hubiera más constantes seguiríamos con 2, 3, etc. Si por alguna razón nos interesa dar un número concreto a cada valor podemos hacerlo en la declaración: en un colores {rojo = 4, azul, verde = 3, negro = 1}; azul tomará el valor 5 (4+1), ya que no hemos puesto nada. También se pueden usar números negativos o constantes ya definidas. Para declarar un variable de un tipo enumerado hacemos: en un booleano test; // sintaxis de ANSI C booleano test; // sintaxis de C++En ANSI C los enumerados son compatibles con los enteros, en C++ hay que convertir los enteros a enumerado: booleano test = (booleano) 1; // asigna TRUE a test (valor 1)

15Si al definir un tipo enumerado no le damos nombre al tipo declaramos una serie de constantes: en un {CERO, UNO, DOS}; Hemos definido las constantes CERO, UNO y DOS con los valores 0, 1 y 2.

Tipos derivados

De los tipos fundamentales podemos derivar otros mediante el uso de los siguientes operadores de declaración:

* Puntero

& Referencia

[] Vector (Array)

() Función

Ejemplos:

int *n; // puntero a un entero

int v[20]; // vector de 20 enteros

int *c[20]; // vector de 20 punteros a entero

void f(int j); // función con un parámetro entero

El problema más grave con los tipos derivados es la forma de declararlos: los punteros y las referencias utilizan notación prefija y los vectores y funciones usan notación postfija. La idea es que las declaraciones se asemejan al uso de los operadores de derivación. Para los ejemplos anteriores haríamos lo siguiente:

int i; // declaración de un entero i

i = *n; // almacenamos en i el valor al que apunta n

i = v[2] // almacenamos en i el valor de el tercer elemento de v

// (recordad que los vectores empiezan en 0)

i = *v[2] // almacenamos en i el valor al que apunta el tercer puntero de v

f(i) // llamamos a la función f con el parámetro i

Hay que indicar que otra fuente de errores es la asociación de operadores, ya que a veces es necesario el uso de paréntesis. Por ejemplo, en la declaración de c anterior hemos declarado un vector de punteros, pero para declarar un puntero a un vector necesitamos paréntesis:

int *c[20]; // vector de 20 punteros a entero

int (*p)[20] // puntero a vector de 20 enteros

Al declarar variables de tipos derivados, el operador se asocia a la variable, no al nombre del

tipo:

int x, y, z; // declaración de tres variables enteras

int *i, j; // declaramos un puntero a entero (i) y un entero (j)

int v[10], *p; // declaramos

...