Cursillo de C++ (IV).
Aquí está la cuarta entrega del cursillo. La siguiente la mandaré A PARTIR del día 13 de febrero. En esta entrega veremos las variables: qué son, qué tipos tenemos y cómo declararlas. Sigue sin ser suficiente para hacer programas útiles, pero nos vamos acercando.
He vuelto a ampliar materia por medio de notas a pié de página, y aunque posiblemente se salgan bastante del nivel del texto general, los que sí han tenido algón contacto con el lenguaje seguramente los agradecerán.
También esta vez he metido un par de ejercicios sencillos. Para que te los corrija, mándame tus respuestas por NET al 2:341/66.3, y te devuelvo por NET las correcciones ¿ok?.
Una cosa más, no te asustes por el tamaño (yo ya me he asustado por todos). El contenido no es tan abstracto como el tema podría incitar y simplemente es que está bastante desarrolado.
Y aquí lo tienes :)
=== { /*cpp_4.txt*/ ===
4 VARIABLES
En esta sección veremos:
~~~~~~~~~~~~~~~~~~~~~~~~
Las variables. Tipos de datos de »serie«. Declaración de las variables. Asignación de un valor en la declaración. Declaración de varias variables de un mismo tipo.La elección de nombres para las variables.
Contenido:
~~~~~~~~~~
LAS VARIABLES
En un programa necesitamos guardar valores que van cambiando de un momento a otro. A esos valores les llamamos variables. A los datos variables, les damos un nombre, y utilizamos ese nombre para representar el valor actual de ese dato variable. Pero los datos variables pueden ser de diferentes tipos: números enteros, números en coma flotante (es decir, números reales), letras, etc.
Ejemplos de variables en el mundo real son: el día en que estamos, la temperatura de la habitación, cuántos años tenemos.
Por todo ello tiene que haber algún mecanismo de decir que queremos utilizar una variable, qué nombre le damos y de qué tipo va a ser. Y en C/C++, sugún el sitio donde lo digamos, vamos a definir en qué zona del programa se conoce la existencia de esa variable (en qué zona es visible). Dar toda esa información se llama declarar la variable, y es muy sencillo de hacer. Una declaración típica sería:
int numero;
Con eso estamos diciendo: declaro la variable numero como un int (número entero). Como he dicho antes, al declararla, según el sitio donde pongamos la declaración, decimos implicitemente en qué zona es visible. Para eso necesitamos saber qué es un bloque de instrucciones.
Bloque de instrucciones son un conjunto de instrucciones de C/C++ encerrados por un abrir llave/cerrar llave ({ }). Siempre que en C/C++ se requiera una instrucción, se puede poner en su lugar un bloque de instrucciones (pero no al revés, y eso lo digo por las funciones, p. ej. la ya conocida main(), que requieren para su cuerpo un bloque de instrucciones, es decir, el cuerpo de una función siempre va delimitado por llaves ({ })).
La variable es visible desde que se declara hasta el final del bloque de instrucciones en que se declara. Si está fuera de todo bloque, la variable se dice que es global y se ve desde todos sitios a partir del punto en que se declara. Si se declara dentro de un bloque(1), se dice que la variable es local (porque tiene una visibilidad local, en el bloque en que se declara). Esto lo veremos con más detalle en cuanto veamos funciones, por ahora nos vamos a contentar con declarar variables locales (las que no son globales, las que están dentro de algún bloque).
Una vez que tenemos la variable declarada, podemos asignarla valores e introducirla en expresiones o como parámetro de funciones. Veamos un ejemplo sencillo (y bastante tonto, todo sea dicho):
===[declvar.cpp]===
/*
* declvar.cpp
*
* Ejemplo de declaración de una variable local.
*/
#include <iostream.h>
void
main()
{
int numero;
numero=1;
cout << "numero tiene el valor " << numero << endl;
numero=2*numero+5;
cout << "numero tiene ahora el valor " << numero << endl;
}
===[declvar.cpp]===
Todo el programa es muy parecido a los que hemos visto hasta ahora. En este caso la salida del programa será algo así como:
numero tiene el valor 1
numero tiene ahora el valor 7
Vamos a ver primero qué pueden contener las variables (qué tipos tenemos disponibles) y después cómo modificarlar y utilizarlas (los operadores). Después de eso, entender el programa anterior debería algo trivial. Vamos a ello.
TIPOS DE DATOS »DE SERIE«
En C/C++ tenemos varios tipos de datos de serie (o primitivos), si bien en C++, mediante una característica denominada extensibilidad de tipos podemos definir otros que estén tan bien integrados con el sistema que no los podamos distinguir de los »de serie«, éstos tienen especial importancia porque son los más básicos.
Se puede decir que en C/C++ existen los siguientes tipos(2): char, enum, int, float y double, a los que el C++ añade el wchar_t.
Una nota sobre el wchar_t: el wchar_t está definido en stddef.h, y es para soportar carácteres de dos bytes (por ejemplo UNICODE). No conozco su nivel de estandarización, por lo que no voy a considerarlo en la siguiente explicación. El nombrarlo es simplemente por saber que existe si se le necesita(3).
A los tipos se le pueden poner unos modificadores de tamaño (long (largo) y short (corto)), y unos modificadores sobre el dominio (signed (con signo) y unsigned (sin signo)(4)). En la siguiente tabla(5) asumo que si no especificamos el dominio, el compilador lo toma como signed, y estamos utilizando un compilador de 16 ó 32 bits.
Tipo Tamaño Rango
+ +
unsigned char 8 bits 0 a 255
char 8 bits -128 a 127
enum 16 o 32
unsigned short 16 bits 0 a 65,535
short 16 bits -32,768 a 32,767
int 16 o 32
unsigned long 32 bits 0 a 4,294,967,295
long 32 bits -2,147,483,648 a 2,147,483,647
float 32 bits 3.4 * (10**-38) a 3.4 * (10**+38)
double 64 bits 1.7 * (10**-308) a 1.7 * (10**+308)
long double 80 bits 3.4 * (10**-4932) a 1.1 * (10**+4932)
En la tabla hay que tener en cuenta tres cosas:
El int y el enum son de 16 bits en sistemas 16bit y de 32 bits en sistemas 32bit.
En algunos casos se puede omitir parte del nombre del tipo: short implica short int y long implica long int.
Realmente el estándar dice que char<short<=int<=long(6), con lo que la tabla de ahí arriba no tiene por qué cumplirse siempre (aunque todos lo compiladores de 16 y 32bit que conozco la cumplen).
Vamos a verlos más en detalle:
char y unsigned char:
En C/C++ las letras (hablando propiamente debería decir los carácteres, como puede ser la letra a ('A') o el carácter punto ('.')) son su código ASCII (así la letra 'A' tiene de código 65).
Cuando nosotros decimos en un programa en C algo del estilo de
char letra;//declaración de la variable letra
letra='A'; //asignamos a la variable letra el valor de 'A'
el compilador lo trata como
char letra;//declaración de la variable letra
letra=65; //asignamos a la variable letra el valor de 'A'
El que sea signed o unsigned determina el rango del char (signed va de -128 a 127, mientras que unsigned va de 0 a 255).
enum:
Es un tipo de dato muy especial, ya que sirve para hacer enumeraciones de palabras que han de tener un valor determinado (decimos el número que corresponde a cada palabra, pudiendo omitir el valor si los números son consecutivos), y después esa enumeración se trata como un tipo de datos diferente. Además es muy útil en conjunción con el tipo int, ya que puedes asignar enums a ints.Se suele utilizar para cosas tan variadas como para enumerar los meses del año o enumerar los mensajes de error. Pongo a continuación un ejemplo de todo esto.
===
#include <iostream.h>
void
main(void)
{
enum meses { enero=1,febrero,marzo, abril, mayo,
junio,julio, agosto, septiembre, octubre,
noviembre, diciembre}; //declaración del nuevo tipo meses.
int mi_mes;
mi_mes=marzo;
cout << "El mes es: " << mi_mes << endl;
}
===
La salida del programa es:
El mes es: 3
Como ya hemos visto, se puede asignar un enum a un int. Los enums también nos permiten evitar los »números mágicos«(7) que habíamos visto en nociones básicas sobre el preprocesador. Un ejemplo típico sería cuando hemos definido un enum con los errores que puede haber en el programa:
enum codigo_error { ok=0, error_lectura=1, error_escritura=2};
y en un momento dado del programa (suponiendo que existe una función llamada copia() que usa los códigos anteriores) podemos hecer algo como:
int error;
error=copia("hola.txt","adios.txt");
y en otro punto del programa podríamos comparar copia con ok, error_lectura y error_escritura.
short, int y long:
Los tres se utilizan de forma parecida, diferenciándose únicamente en el número más grande que se puede almacenar en cada uno de esos tipos de datos.
Cuando tenemos que almacenar un número entero, utilizaremos estos tipos de datos, de la siguiente manera:
// Ejemplo de declaración y asignación de un short int
short entero_corto;
entero_corto=4325;
// Ejemplo de declaración y asignación de un int
int entero;
entero=13784;
// Ejemplo de declaración y asignación de un long int
long entero_largo;
entero_largo=57382L;
Como he mostrado en el ejemplo, a las constantes numéricas de tipo long, se les añade después del número una L, de otra forma el número se supone de tipo int (que son constantes que se pueden utilizar con char, short e int indistintamente, aunque si son más grandes de lo que el tipo de destino puede almacenar, el número se truncará(8))
float, double y long double:
Estos tipos son los que nos permiten utilizar números en coma flotante (números reales), tales como 3.141592654, 2.5, etc.
Entre ellos sólo se diferencian en la precisión que nos dan y en la forma de poner las constantes de dichos números. Como regla general, para los números en los que basten con 6 dígitos de precisión, utilizaremos float, para los que necesitemos 12 dígitos, utilizaremos double, y si necesitamos más, utilizaremos long double.
Las constantes numéricas se escriben utilizando un punto para separar la parte entera de la parte decimal o farccionaria, y si lo ponemos en forma científica, utilizando una e minúscula (e) o mayúscula (E) para separar el número del exponente. Ejemplos de números así puestos serían: 10.5, 124.0, 15.4e15 (este último número sería 15.4*(10**15), si el asterisco-asterisco (**) fuera el símbolo de »elevado a« que el C/C++ no posee), 0.012E5, 124.531, 53e3, 6.4E4. Por último, se pone un sufijo para decir a cuál de los tipos de número en coma flotante corresponde ese número:
Sufijo Tipo Ejemplo
f, F float 10.3e5f
(nada) double 12.6e4
l, L long double 1.54e10l
Unos ejemplos de declaración y asignación de números en coma flotante serían:
// Ejemplo de declaración y asignación de un float
float numerof;
numerof=3.1415f;
// Ejemplo de declaración y asignación de un double
double numerod;
numerod=143e5;
// Ejemplo de declaración y asignación de un long int
long double numerold;
numerold=4.53564e12L;
Y esos son todos los tipos que tenemos disponibles »de serie«. Había comentado al principio que el C++ nos permite definir nuevos tipos y las operaciones entre ellos, de manera que estén igual de integrados con el sistema que los de serie. Si has echado en falta un tipo de dato para números complejos, no te preocupes, porque en C++ está soportado mediante una clase (en la librería estándar de clases) que se llama complex y que está definida en complex.h. En lo único que se diferencia su uso del de los números en coma flotante es en la manera de definir un número complejo, que es por medio de constructores(9), los cuales veremos en su momento.
Nos faltan por ver sólo dos cosas respecto a la declaración de variables: que se pueden asignar valores a las variables en su declaración y que se pueden declarar varias variables del mismo tipo a un tiempo.
ASIGNACION DE VALORES A LAS VARIABLES EN SU DECLARACION
A esto también se lo denomina inicialización de variables en la declaración. La asignación de un valor a una variable cuando la declaramos es muy sencilla. Basta con poner detrás del nombre de la variable un igual (=) y el número que le queremos dar inicialmente. Veamos unos ejemplos:
int numero=184;
long cantidad=162626L;
float altura=180e-2f;
long double pi=3.141592654L;
DECLARACION DE VARIAS VARIABLES DE UN MISMO TIPO
Cuando declaramos varias variables de un mismo tipo, podemos agrupar su declaración, poniendo el tipo de las variables, y después el nombre de cada una de ellas separadas por comas, como por ejemplo:
int i,j,k;
i=10;
j=25;
k=j;
Y, por supuesto, se puede asignar valores a las variables así agrupadas. Vamos a ver un ejemplo parecido al del principio de la sección con todo esto que hemos visto:
===[declvar2.cpp]===
/*
* declvar2.cpp
*
* Ejemplo de declaración y asignación de valores a
* variables.
*/
#include <iostream.h>
void
main()
{
char letra='c';
int numero=1,otro_numero;
float pi=3.14159f,radio=4.0f;
cout << "numero tiene el valor " << numero << endl;
otro_numero=2*numero+5;
cout << "otro_numero tiene ahora el valor " << numero << endl;
cout << "El área de un círculo de radio " << radio << " es " <<
pi*radio*radio << endl;
}
===[declvar2.cpp]===
ELECCION DE NOMBRES PARA LAS VARIABLES
Los nombres de las variables tienen ciertas restricciones:
no pueden empezar por un número.
sólo se pueden utilizar carácteres ASCII (<=127), con lo que nos tenemos que olvidar de nuestra querida Ñ y ñ, así como de poner acento gráfico (tilde) a las vocales (no podemos utilizar tampoco áéíóú).
No se pueden utilizar los símbolos que se utilizan como operadores.
No se puede dar como nombre de una variable una palabra clave del lenguaje (tal como int, short, if, for,...).
Con esas restricciones, lo más sencillo es limitarse a las letras mayúsculas y minúsculas anglosajonas, así como los números y el carácter de subrayado (_), teniendo en cuenta que no podemos empezar el nombre de una variable con un número.
EJERCICIOS
1.- Pon un ejemplo de una declaración con inicialización de cada uno de los tipos de variables que hemos visto.
2.- Di si cada uno de los siguientes nombres serían válidos para ser nombre de una variable:
notación for hola
niños AdIoS numero3
_EO 3cosas nombre_y_apellidos
Aquí termina la 4º entrega.
-+-
(1) Una de las diferencias que hay entre el C y el C++, es que el C pone más restricciones respecto al lugar donde se declaran las variables locales. En C++ se pueden poner las declaraciones en cualquier lugar del bloque (y se recomienda que sea cerca del punto donde se va a utilizar), mientras que en C sólo se pueden declarar las variables locales al principio del bloque (detrás del abrir-llave ({) o detrás de otra declaración).
(2) Esta definición de los tipos de serie no es muy rigurosa, pero es la que se da en los sistemas de 16bit y de 32bit que utilizo. Si alguna no es extensible a otros sistemas, mandame un NET (Fido) al 2:341/66.3
(3) En principio el wchar_t se maneja de manera análoga al char, sólo que en este caso sus constantes se expresan con una L mayúscula delante, seguida de dos letras entre comilla simple (') como por ejemplo en L'ab'
(4) En la mayoría de lo compiladores de C/C++, cuando no se especifica ni signed ni unsigned, se asume signed, pero no tiene por qué ser así. De todas formas, en los pocos en los que no asumen signed, suele poder activarse una opción para que sean signed por defecto, por lo que es razonablemente seguro el omitir el signed.
(5) Gentileza del sistema de ayuda del Borland C++ v3.1, (c) Borland Intl., Inc, etc, etc.
(6) En C/C++ se utiliza el símbolo <= para representar »menor o igual«.
(7) Los números mágicos eran números que aparecen en el programa y hacen que funcione, pero para un lector »casual« del programa no significan nada (p. ej. variable=80, es menos evidente que un variable=COLUMNAS_PANTALLA). Los enums también ayudan a evitar los números mágicos
(8) En C/C++ los números enteros se truncan a nivel de bits. Así, si se asigna a una variable de 16bits un dato de 32bits, en la variable sólo se guardarán los 16 bits menos significativos del dato. El C++ es un lenguaje tipado, al contrario que el C (que no protestaba cuando se introducía in int en vez de un char, por ejemplo: el C hacía silenciosamente la conversión truncando el valor si era necesario), por lo que en C++ vamos a necesitar forzar las conversiones aunque en un principio parezca que no son peligrosas, como podría ser dar un char a una función en vez de un int, o dar un número sin signo en vez de uno con signo. Eso se hace por medio de la conversión forzada de tipos o »casting«, que veremos cuando veamos los operadores.
(9) Los constructores, como su nombre indica, se utilizan para construir nuevos elementos de una determinada clase (u objeto). A cada elemento construido se le llama instancia de ese objeto. La manera de construir números complejos es poniendo algo de la forma de complex(134,-5.9), siendo 134 la pate real y -5.9 la parte imaginaria. Si se define el valor en su declaración, se pone justo después del nombre de la variable: complex numero(5,6); Dicho así quizás parezca un poco raro, pero es debido a que está definido como una clase y esa es la manera de construir objetos de una clase, como veremos más adelante.
=== } /*cpp_4.txt*/ ===
Es increíble que hayas llegado hasta aquí abajo :-b. Pero ya que lo has hecho, recordarte que las variables son uno de los dos pilares básicos para la programación en C/C++ (lo has adivinado, el otro son las funciones -- y encapsulando datos y funciones tendremos las clases).
Eso significa que se puede decir que ya sabes un 50% de lo básico }:).
Bromas aparte, nos vemos en la siguiente entrega ;)
Datos del autor/a:
Nombre: Dario Rodriguez.
Votaciones en general - Comentario a los relatos (mes anterior) - Comentario a los relatos (mes presente) - Estadísticas de los comentarios y votaciones.
[Indice general] - [Sexo] - [linux] - [humor] - Chat entre usuarios - [miscelanea] - [Novedades] -
