1.

INTRODUCCION

En esta seccin veremos:

~~~~~~~~~~~~~~~~~~~~~~~~

Algo de la historia del C++. Caractersticas del C++.

Contenido:

~~~~~~~~~~

Creo que no es nada nuevo el decir que el C++ es un lenguaje de programacin

orientado a objetos (no tanto como el Smalltalk o el Objective C, pero s lo
suficiente como para recibir dignamente ese nombre), y est diseado partiendo
del lenguaje C. As se ha hablado mucho de l como un el lenguaje orientado a
objetos para los programadores de C (ya que casi todas las caractersticas y
construcciones del C tambin estn disponibles en el C++), pero eso no es ser
muy justo, ya que es un lenguaje por s mismo y no una simple extensin del
lenguaje C. Para empezar, no viene mal un poco de su historia (extrado del
manual de referencia de C/C++ del IBM C Set++, (C) IBM Corp, etc, etc):

El C++ fue desarrollado por Bjarne Stroustrup de AT&T, y estaba basado

originalmente en la definicin del lenguaje C dada en "El lenguaje de
programacin C" (The C Programming Language) de Brian W. Kernighan y
Dennis M. Ritchie. Desde entonces fue aprobada la definicin ISO/ANSI C, que
especifica muchas de las caractersticas que K&R dej sin especificar. Algunas
de las caractersticas del ISO/ANSI C se han incorporado en la definicin actual
del C++, y algunas partes de la definicin ISO/ANSI C han sido motivadas por el
C++.

Mientras que no hay actualmente un estndar de C++ comparable con la

definicin del ISO/ANSI C, un comit ISO est trabajando en esa definicin. El
borrador del "Working Paper for Draft Proposed American National Standard for
Information Systems - Programming Language C++, X3J16/92-0091" es el
documento base para la estandarizacin que se est llevando a cabo en el C++.

Bsicamente la idea es que Stroustrup necesitaba (segn tengo entendido) un

lenguaje que le permitiera aplicar mejor IA (inteligencia artificial), y su equipo de
trabajo principalmente utilizaba el C, con lo que lo ms sencillo fue disear un
lenguaje que aceptase la mayor parte del cdigo y construcciones del C pero
orientado a objetos. En las primeras implementaciones no hicieron un verdadero
compilador de C++, sino un mero traductor de C++ a C (el CFRONT de AT&T).
Cuando ms adelante salieron compiladores de C++, se adheran a las
caractersticas del C++ de AT&T. Ms tarde se dej el proceso de estandarizacin
a un comit, y ese proceso de estandarizacin es el que lleva a cabo la ISO
(International Standards Organization). Actualmente ya est a punto de salir (y se
puede mirar y dar tu opinin en http://www.setech.com/x3.html y en
http://www.maths.warwick.ac.uk/c++/pub)

Ya est bien de historia, me parece. Lo importante es que el C++ es un lenguaje

robusto y suficientemente bien diseado que nos proporciona una manera de
expresar las ideas en programas cmoda y concisa, aunque con la suposicin
(heredada del C) de que el programador sabe lo que hace, con sus ventajas e
inconvenientes, lo que implica que el programador debe de ser consciente de que
el lenguaje apenas pone restricciones en su uso (an as el C++ es mucho ms
"pejiguero" que el C, por ejemplo en la comprobacin de tipos... pero eso es algo
que ya veremos ms adelante).

Una curiosidad: Por qu llamarle C++ ("C plus plus" es como lo llaman los
yanquis, aunque hay formas de leer su nombre para todos los gustos) y no D
(parece lgico que despus de la C vaya la D) o C+ (C "plus")? Realmente no lo
s, pero lo que s puedo decir es que fue una eleccin acertada, ya que su nombre
es una sentencia vlida del lenguaje que viene a significar algo as como "asigna
a C el valor C ms 1". Pocos lenguajes tienen encerrados en su nombre tiene
tanta filosofa...

Creo que con unas referencias como estas es una buena idea el ver por nosotros
mismos de qu va este lenguaje y aprender un poco de l, no? Pues all vamos.
Os espero en la siguiente entrega ;)

Cursillo de C++ (II) .

Aqu est la segunda entrega del cursillo. Esta entrega espero que sirva para que
si no has visto nunca un programa de C++, te vayan acostumbrando a su aspecto.
Si por el contrario has tenido oportunidad de ver programas o tienes experiencia
con C, tes sonar a concocido (o eso espero).

Si algo no queda claro, no dudes en preguntar. Si no te has enterado de nada, no

me importa volver a redactar la entrega, basta con que lo digas. O sea que estoy a
la espera de tus preguntas, comentarios, etc.

Cuando el curso haya avanzado algo, espero poder empezar a poner ejercicios,
pero todava es algo pronto para ello.

Los numeritos entre parntesis detrs de algunas palabras son notas a pi de

pgina. Las he puesto al final del texto. Generalmente son aclaraciones sobre
palabras que seguramente no conozcas o adelantar algo de materia :).

Et voil!

=== { /*cpp_2.txt*/ ===

2 EL PROGRAMA DE Hola mundo!

En esta seccin veremos:

~~~~~~~~~~~~~~~~~~~~~~~~

Los comentarios. Decir qu vamos a utilizar para que el compilador sepa cmo se
utiliza. Dnde ponemos el cdigo. Los datos.

Contenido:

~~~~~~~~~~

EL PROGRAMA DE "HOLA MUNDO"

Pues para empezar con algo tangible, vamos a ver el tpico programa de Hola
mundo! (s, ese que lo nico que hace es poner en pantalla ese curioso saludo).
Pues no esperemos ms, aqu lo tenemos:

===[hola.cpp]===

/*

* hola.cpp
*/

#include <iostream.h>

void

main() {

cout << "Hola Mundo!";

===[hola.cpp]===

Ya tenemos ah un pequeo programita que hace algo, poner un mensaje en la

pantalla. Nos va a servir para ver cmo es un programita en C++. Si bien el
ejemplo es casi la mnima expresin de lo que se puede hacer, ya tiene los
suficientes elementos como para que se merezca un examen ms detallado.

Un programa sencillo de C++ lo podemos dividir en varias partes. Vamos a ver

las de ste, pero antes voy a numerar las lneas del programa anterior para poder
hacer referencia a las diferentes partes.

===[hola.cpp]===

1: /*

2: * hola.cpp

3: */

4:

5: #include <iostream.h>

6:

7: void

8: main() {

9: cout << "Hola Mundo!";

10: }

===[hola.cpp]===

Este programita slo tiene tres partes:

Lneas 1-3: comentarios

Lnea 5: en este caso, mencionar que mire cmo se usa el cout que utilizaremos
despus(1).

Lneas 7-10: es el programa en s mismo (aqu, simplemente el cdigo). Contiene

el cuerpo (cdigo) de las funciones.

Vamos a verlas con un poco ms de detalle y digamos algo sobre cada una de
ellas.

ANALISIS DEL PROGRAMA

Comentarios (lneas 1 a 3):

Los comentarios en C++ pueden ser de dos formas; rodeando un texto (las que he
utilizado en el programa) y las que indican que el resto de la lnea es un
comentario. Los comentarios que se delimitan por los extremos, se empiezan con
un /* (barra-asterisco) y se terminan con un */ (asterisco-barra). Todo lo que est
entre esas dos cosas es un comentario, que puede ser de varias lneas de longitud.
Un ejemplo:

/* Yo soy un comentario de varias

lneas, no importa el tamao */

Los otros asteriscos que se ven en el programa (lnea 2) son slo de "adorno".

El otro tipo de comentarios, que no aparecen en el programa, son los de una sla
lnea, y su inicio se indica con un // (barra-barra), su fin es el fin de la lnea (el
ENTER, por decirlo de alguna manera). Un ejemplo:

// Comentario de una sla lnea

Los comentarios del tipo de /**/ son los que haba en el lenguaje C (y por
supuesto, sigue habindolos en C++), mientras que los de // son exclusivos del
C++. Una cosa ms: los comentarios se puede poner prcticamente en cualquier
sitio.

Incluir ficheros de prototipos (lnea 5):

Como ya he mencionado de pasada antes, en esta lnea le decimos que mire el

fichero que se indica entre < > (mayores y menores que). Normalmente un
programa tendr varias lneas de estas, ya veremos cundo necesitamos
utilizarlas.Un pequeo adelanto: las lneas que empiezan por # (almohadilla) se
tratan de forma especial y se denominan directivas del preprocesador. Ese
nombre tan curioso les viene porque la parte del compilador(2) que las interpreta
es el preprocesador, y las dos ms comunes son #include y #define(3).

Cdigo (lneas 7 a 10):

Todo lo anterior estaba muy bien, pero nosotros queremos un programa que haga
algo. Y dnde ponemos las cosas que queremos que haga? En main() (4).

Cuando nosotros ejecutemos el programa, lo que va a ir haciendo es la lista de

cosas que le hayamos puesto dentro de main(), si miras el listado, vers en la
lnea 8 un { (abrir-llave) y en la lnea 10 un } (cerrar-llave), que delimitan lo que
es main() propiamente dicho.

La palabra void que hay antes de main() indica que main() no devuelve ningn
resultado al sistema operativo (void significa vaco).

En el cuerpo de la funcin (la parte entre llaves) nos encontramos con una sla
instruccin (lnea 9), en la cual se manda un mensaje a cout. Antes habamos
includo el fichero iostream.h (lnea 5), slo para que el compilador supiera
cmo se puede llamar a cout. Pues bien, cout representa el dispositivo de salida
estndar, que suele ser la pantalla, y est definido de tal manera que las cosas que
queramos que se impriman en pantalla se le pasan poniendo entre el cout y el
mensaje un << (menorque-menorque).

El ; (punto y coma) es para decir que ah termina la instruccin. Siempre, despus

de una instruccin, va un punto y coma. Recurdalo, porque siempre se termina
olvidando alguno y el compilador dir que hay algn error en el programa, pero
con mensajes de error no siempre claros.

Y LOS DATOS?
Pues en ese programa tan pequeo, no se han definido esplcitamente datos. Los
datos se pueden poner en cualquier sitio, pero slo puedes utilizarlos en un sitio
posterior a donde se han definido (en C haba una restriccin para las
definiciones de datos dentro de una funcin: slo podan estar justo detrs del
{ (abrir-llave) o siguiendo a otra definicin de datos).

Otra cosa ms sobre los datos: no es lo mismo colocarlos dentro que fuera de un
cuerpo de una funcin (si es dentro de una funcin slo se puede utilizar dentro
de la funcin en la que se ha definido y antes del siguiente } (cerrar-llave).

Todo esto lo veremos cuando lleguemos al captulo de las variables, por ahora
nos basta con saber que s se pueden poner datos en diferentes partes del
programa y que importa el lugar donde se coloquen.

Esto es todo en esta entrega, ya nos veremos en la siguiente...

-+-

(1) Al texto que le dice al compilador cmo se usa 'algo' se le denomina

prototipo, y la lnea esa le dice que incluya, es decir, que se mire, el fichero de
prototipos con el nombre iostream.h

(2) Entendiendo por compilador el programa que coge el fichero fuente de un

determinado lenguaje y genera un programa que el ordenador pueda entender, lo
cual no es ser muy rigurosos.

(3) Ya lo veremos ms adelante cuando de las nociones bsicas sobre el

preprocesador, pero si te pica la curiosidad #define permite hacer dos cosas,
poder llamar a las constantes con un nombre (p. ej decir DISTANCIA_MAXIMA
en vez de 50) y crear macros, que son una especie de constantes parametrizadas...
pero eso ya es materia de otro captulo, ya veremos cada cosa a su tiempo.

(4) Como main es una funcin, la pondremos seguida de parntesis, quedando

main(). Las funciones son la base de la programacin estructurada, y se utilizan
para agrupar una secuencia de intrucciones (cosas que quieres que haga el
ordenador) que son para un fin comn. Ya te habrs dado cuenta que main
significa principal, y es porque es la funcin principal del programa, la que ir
llamando al resto para hacer el cometido exacto del programa. Siendo ms
rigurosos, main() representa el punto de entrada del programa.

=== } /*cpp_2.txt*/ ===

Espero que te haya gustado esta toma de contacto. Te espero en la prxima
entrega ;).

Cursillo de C++ (III) .

Aqu est la tercera entrega del cursillo. La siguiente la mandar sobre el da 2 de

Enero (de 1998, por supuesto ;). En esta entrega veremos algo sobre el
preprocesador. Todava no es suficiente para hacer programas tiles, pero es una
de los elementos imprescindibles de los programas en C/C++.

He puesto algunos ejemplos, y espero que las explicaciones estn

suficientemente dtalladas, pero si no comprendes algo, no dudes en preguntar
(sobre todo si te salen dudas sobre #define, que al fin y al cabo es bastante
diferente de lo que hay en otros lenguajes).

He metido un par de ejercicios sencillos. Para que te los corrija, mndame tus
respuestas por NET al 2:341/66.3, y te devuelvo por NET las correcciones ok?.

He puesto una nota a pie de pgina... pero est algo fuera del nivel del captulo, o
sea que tampoco te preocupes mucho por ella.

Y aqu lo tienes :)

=== { /*cpp_3.txt*/ ===

3 NOCIONES BASICAS SOBRE EL PREPROCESADOR

En esta seccin veremos:

~~~~~~~~~~~~~~~~~~~~~~~~

El preprocesador y el compilador. Qu nos permite hacer el preprocesador.

Distinguir las directivas del preprocesador del resto del programa. La directiva
#include. La directiva #define para las constantes y las macros. Ejercicios.

Contenido:
~~~~~~~~~~

EL PREPROCESADOR Y EL COMPILADOR

No quera continuar el cursillo sin dejar claro que lo que nosotros llamamos
habitualmente el compilador de C/C++, realmente son dos programas diferentes
que trabajan en equipo. Los programas son: el preprocesador, que slo prepara el
cdigo fuente con ciertas tareas que podramos denominar de buscar/reemplazar,
y el compilador, que traduce nuestro bonito programa en C/C++ a cdigo objeto
(instrucciones del procesador mas algo de informacin para otros programas que
nos permitirn mezclar cdigo de varios compiladores y depurar el programa, por
mencionar dos de los usos ms importantes).

Mientras que est muy clara cul es la funcin del compilador, el que haya un
preprocesador puede parecer un poco extrao, sobre todo porque a la mayora de
los lenguajes les va muy bien sin ningn tipo de preprocesador. Vamos a ver
entonces qu servicios nos proporciona el preprocesador.

QUE NOS PERMITE HACER EL PREPROCESADOR

Las funciones bsicas del preprocesador son:

Incluir ficheros en el programa (mediante #include).

Definir constantes (por medio de #define).

Definir macros (una especie de constantes parametrizadas, tambin con #define)

Hacer compilacin condicional (dependiendo de si estn definidas ciertas

constantes, que omita o no ciertas partes del fichero, mediante #ifdef, #ifndef, #if
defined(), #elif, #else y #endif)

Provocar errores (mediante #error, su utilidad viene dada cuando se utiliza junto
con la compilacin condicional)

Activar ciertas caractersticas del compilador (mediante #pragma).

Las ms importantes, como podrs suponer, son las tres primeras, que son las que
vamos a ver en esta entrega. El resto las dejamos para cuando veamos el
preprocesador en profundidad.

Una cosa ms antes de meternos con algunas de las directivas del preprocesador:
en algunos textos de C++ se comenta que se tiende a intentar hacer menos uso
del preprocesador, y de hecho, que se aconsejaba que se usasen otras
caractersticas del lenguaje para el mismo trabajo cuando fuera posible. La
explicacin de esto es que algunas cosas en C slo se podan hacer a base de
macros, mientras que en C++ se pueden hacer tambin mediante el uso de
programacin orientada a objetos (ms exactamente mediante herencia y
polimorfismo, lo que en estos momentos seguramente te sonar a chino; no te
preocupes, que todo llegar). An as su uso es ms que obligado para muchas
tareas bsicas de la programacin en C/C++.

DISTINGUIR LAS DIRECTIVAS DEL PREPROCESADOR DEL RESTO DEL

PROGRAMA

Como ya te habrs podido dar cuanta en la seccin anterior, las directivas del
preprocesador son palabras precedidas por # (almohadilla).

Adems tienen una restriccin con respecto a las instrucciones del compilador
propiamente dicho: la directiva del preprocesador tiene que estar sola en la lnea
(con sus parmetrso si es que los tiene), quedando cosas del estilo de:

===[ejemplospp.h]===

#include <iostream.h>

#include <string.h>

#include "misdef.h"

#if defined(__cplusplus)

#define MAX_VELOCIDAD 50

#endif

===[ejemplospp.h]===

LA DIRECTIVA #include

Como ya hemos visto, nos permite incluir un fichero de texto dentro de otro.
Es algo as cmo antes de continuar, procesa el contenido de este otro fichero.

Su sintaxis es:

#include <fichero_a_incluir>
#include fichero_a_incluir

La diferencia entre encerrar el fichero a incluir entre mayores y menor-ques (< >)
y entre comillas (" "), es en dnde busca el fichero a incluir. Como regla general,
para los ficheros que vienen con el compilador (como por ejemplo iostream.h,
stdio.h, string.h) se ponen entre mayores y menor-ques (< >), mientras que los
ficheros hechos por ti se ponen entre comillas (" "). Esto es as porque los que
pones entre comillas los busca primero en el directorio actual (presumiblemente
el directorio de tu programa), mientras que los otros los busca en el directorio de
nombre include que viene con el compilador.

As pues quedan de la siguiente forma:

===[ejemplosinc.h]===

#include <stdio.h>

#include <stdlib.h>

#include <strstrea.h>

#include defmias.hpp

===[ejemplosinc.h]===

LA DIRECTIVA #define PARA LAS CONSTANTES Y LAS MACROS

Habamos dicho que la directiva #define nos serva para definir constantes y
macros. Veamos cmo se utiliza para cada una de esas tareas.

Una constante es algo que no vara (seguro que esa frase no me acredita para
recibir un premio Nobel). Constantes tpicas que nos encontramos en el mundo
real pueden ser la constante de gravitacin universal, el nmero pi, el nmero de
das que tiene una semana o el ao en que naciste.

Una razn para definir constantes en un programa es para evitar los nmeros
mgicos. Los nmeros mgicos son nmeros que aparecen en el programa y
hacen que funcione, pero que no sabes por qu funcionan (debido a que no sabes
qu representan). El uso de constantes en vez de nmeros mgicos tiene dos
ventajas: si por cualquier causa tienes que modificar el nmero y se utiliza en
varios sitios, el haberlo definido como una constante en un slo sitio hace ms
fcil el cambio; por otra parte se entiende mejor el programa, ya que se sabe qu
es lo que representa la constante (compara un si x es mayor que 40 da un pitido
con si x es mayor que COLUMNAS_PANTALLA da un pitido).

A efectos prcticos el #define hace, ms o menos, un buscar y reemplazar en el

programa a partir del punto en el que se han definido.

La sintaxis de #define para definir constantes es:

#define NOMBRE_DE_CONSTANTE

#define NOMBRE_DE_CONSTANTE valor_de_la_constante

El nombre de la constante consiste de letras, dgitos y carcteres de subrayado

(_). No debe empezar por un nmero. Es costumbre escribirlas en maysculas,
para distinguirlas de las instrucciones y variables, pero no es necesario (pero s
muy aconsejable).

Como puedes ver, se pueden definir constantes sin asociar ningn valor a ellas.
Eso sirve para la compilacin condicional, ya que se basa en comprobar si una
constante ha sido definida, independientemente del valor (y de si tiene un valor
asociado o no).

Una vez que has definido una constante, el preprocesador sustituir el nombre de
la constante por el valor de la constante, sin importarle si el valor era un nmero,
un texto, una instruccion o una mezcla de todas ellas (vamos, que el valor de la
constante puede ser cualquier cosa, simpre que lo puedas meter en una sola
lnea).

El ejemplo que voy a poner a continuacin no es muy real (no es normal que las
cosas se hagan de esta manera), pero ilustra el uso de #define para definir
constantes:

===[ejemplospp2.cpp]===

/*

* ejemplospp2.cpp

*/

#include <iostream.h>

#define TEXTO "Hola Mundo!"

#define NUMERO_DE_VEZ 2

#define ESCRIBEHOLAMUNDO cout << "Esto es otro hola mundo."

void

main() {

cout << TEXTO << " nmero " << NUMERO_DE_VEZ << endl;

ESCRIBEHOLAMUNDO;

===[ejemplospp2.cpp]===

Este programa es prcticamente igual al que vimos de Hola Mundo. Lo nico

que no te debera de sonar es el endl, que sirve para que siga escribiendo en la
siguiente lnea.

Cuando el preprocesador llegue a la primera lnea despus del main(), sustituir

TEXTO por Hola Mundo!, NUMERO_DE_VEZ por 2 y
ESCRIBEHOLAMUNDO por el cout << Esto es otro hola mundo., quedando
main() algo del estilo de

===[as queda main despus del preprocesado]===

void

main() {

cout << "Hola Mundo!" << " nmero " << 2 << endl;

cout << "Esto es otro hola mundo.";

===[as queda main despus del preprocesado]===

Slo queda por explicar las macros. Ya me he cansado de repetirlo, pero por una
vez ms no pasa nada. Las macros son una especie de constantes parametrizadas.
Slo se diferencian de las constantes porque hay sustitucin dentro de ellas.
Vamos a ver su sintaxis y un ejemplo sencillo:
La sintaxis de #define para definir macros es (si por ejemplo tiene cuatro
parmetros):

#define NOMBREMACRO(x,y,z,t) expresin_con_los_parmetros

Por supuesto el nmero de parmetros de la macro es el que t quieras. Algunos

ejemplos seran:

===[ejemplosdef.h]===

#define SUMA(a,b) ((a)+(b))

#include RESTA(a,b) ((a)-(b))

#include CUBO(a) ((a)*(a)*(a))

===[ejemplosdef.h]===

Como puedes ver he rodeado en la expresin los parmetros con parntesis. Eso
se hace para evitar efectos laterales (ya que a y b pueden ser cualquier cosa, as
nos evitamos problemas, ahora mismo no nos importa cules, ya lo veremos la
explicacin de estos parntesis cuando veamos los operadores). Una vez que
hemos definido las anteriores macros, las lneas

cout << SUMA(5,4);

cout << CUBO(4);

cout << RESTA(SUMA(CUBO(3),4+3),5);

se transformaran en

cout << ((5)+(4));

cout << ((4)*(4)*(4));

cout << ((((3)*(3)*(3))+(4+3))-5);

Y con esto dejamos por ahora el tema del preprocesador. Lo retomaremos un

poco cuando demos operadores, que nos permitirn hacer un uso ms interesante
de las macros.

Ejercicios
1.- D para qu sirve la directiva del preprocesador #include

2.- D cmo quedar el siguiente fragmento de programa despus de pasar el

preprocesador:

===[pp_ej1.cpp]===

#define HOLA "Hola"

#define QUE_TAL "qu tal"

#define NUMERO 123

#define SUMA(x,y) ((x)+(y))

void

main(void)

cout << HOLA << QUE_TAL << SUMA(NUMERO,34);

===[pp_ej1.cpp]===

Aqu termina la 3a entrega del cursillo.

-+-

(1) Por si tienes curiosidad, la razn principal de que se pongan parntesis es para
evitar efectos laterales cuando se utilizan macros con variables y operadores
unarios (incremento y decremento, por ejemplo), ya que podran salir cosas muy
extraas al hacer la sustitucin: SUMA(a,++b) quedara ((a)+(++b)), pero si no
hubisemos puesto los parntesis hubiera quedado a+++b, que los compiladores
la interpretaran como (a++)+(b), que da un resultado completamente diferente
del que pretendamos (incrementamos a en vez de b y el resultado de la suma es
un nmero menor). En estos momentos esto un pequeo galimatas, pero quedar
claro cuando veamos los operadores.

=== } /*cpp_3.txt*/ ===

Espero que no te haya extraado demasiado el preprocesador del C/C++. Lo
utilizaremos en todos los programas que hagamos, o sea que te acostumbrars a
l en cuanto empieces a hacer programas.

Nos vemos en la siguiente entrega entonces ;)

Cursillo de C++ (IV) .

Aqu est la cuarta entrega del cursillo. La siguiente la mandar A PARTIR del
da 15 de Junio. En esta entrega veremos las variables: qu son, qu tipos
tenemos y cmo 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 pgina, y aunque

posiblemente se salgan bastante del nivel del texto general, los que s han tenido
algn contacto con el lenguaje seguramente los agradecern.

Tambin esta vez he metido un par de ejercicios sencillos. Para que te los corrija,
mndame tus respuestas por NET al 2:341/66.3, y te devuelvo por NET las
correcciones ok?.

Una cosa ms, no te asustes por el tamao (yo ya me he asustado por todos). El
contenido no es tan abstracto como el tema podra incitar y simplemente es que
est bastante desarrolado.

Y aqu lo tienes :)

=== { /*cpp_4.txt*/ ===

4 VARIABLES

En esta seccin veremos:

~~~~~~~~~~~~~~~~~~~~~~~~
Las variables. Tipos de datos de serie. Declaracin de las variables. Asignacin
de un valor en la declaracin. Declaracin de varias variables de un mismo
tipo.La eleccin 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: nmeros enteros,
nmeros en coma flotante (es decir, nmeros reales), letras, etc.

Ejemplos de variables en el mundo real son: el da en que estamos, la temperatura

de la habitacin, cuntos aos tenemos.

Por todo ello tiene que haber algn mecanismo de decir que queremos utilizar
una variable, qu nombre le damos y de qu tipo va a ser. Y en C/C++, sugn 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 informacin se
llama declarar la variable, y es muy sencillo de hacer. Una declaracin tpica
sera:

int numero;

Con eso estamos diciendo: declaro la variable numero como un int (nmero
entero). Como he dicho antes, al declararla, segn el sitio donde pongamos la
declaracin, 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
instruccin, se puede poner en su lugar un bloque de instrucciones (pero no al
revs, 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 funcin
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 ms detalle
en cuanto veamos funciones, por ahora nos vamos a contentar con declarar
variables locales (las que no son globales, las que estn dentro de algn bloque).

Una vez que tenemos la variable declarada, podemos asignarla valores e

introducirla en expresiones o como parmetro de funciones. Veamos un ejemplo
sencillo (y bastante tonto, todo sea dicho):

===[declvar.cpp]===

/*

* declvar.cpp

* Ejemplo de declaracin 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 despus cmo modificarlar y utilizarlas (los operadores). Despus
de eso, entender el programa anterior debera 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 caracterstica denominada extensibilidad de tipos podemos definir
otros que estn tan bien integrados con el sistema que no los podamos distinguir
de los de serie, stos tienen especial importancia porque son los ms bsicos.

Se puede decir que en C/C++ existen los siguientes tipos(2): char, enum, int, float
y double, a los que el C++ aade el wchar_t.

Una nota sobre el wchar_t: el wchar_t est definido en stddef.h, y es para

soportar carcteres de dos bytes (por ejemplo UNICODE). No conozco su nivel
de estandarizacin, por lo que no voy a considerarlo en la siguiente explicacin.
El nombrarlo es simplemente por saber que existe si se le necesita(3).

A los tipos se le pueden poner unos modificadores de tamao (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 Tamao 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 estndar 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 ms en detalle:

char y unsigned char:

En C/C++ las letras (hablando propiamente debera decir los carcteres, como
puede ser la letra a ('A') o el carcter punto ('.')) son su cdigo ASCII (as la letra
'A' tiene de cdigo 65).

Cuando nosotros decimos en un programa en C algo del estilo de

char letra;//declaracin de la variable letra

letra='A'; //asignamos a la variable letra el valor de 'A'

el compilador lo trata como

char letra;//declaracin 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 nmero que
corresponde a cada palabra, pudiendo omitir el valor si los nmeros son
consecutivos), y despus esa enumeracin se trata como un tipo de datos
diferente. Adems es muy til en conjuncin con el tipo int, ya que puedes
asignar enums a ints.Se suele utilizar para cosas tan variadas como para enumerar
los meses del ao o enumerar los mensajes de error. Pongo a continuacin 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}; //declaracin 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 tambin
nos permiten evitar los nmeros mgicos(7) que habamos visto en nociones
bsicas sobre el preprocesador. Un ejemplo tpico sera 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 funcin llamada
copia() que usa los cdigos anteriores) podemos hecer algo como:

int error;

error=copia("hola.txt","adios.txt");

y en otro punto del programa podramos comparar copia con ok, error_lectura y
error_escritura.

short, int y long:

Los tres se utilizan de forma parecida, diferencindose nicamente en el nmero

ms grande que se puede almacenar en cada uno de esos tipos de datos.

Cuando tenemos que almacenar un nmero entero, utilizaremos estos tipos de

datos, de la siguiente manera:

// Ejemplo de declaracin y asignacin de un short int

short entero_corto;

entero_corto=4325;

// Ejemplo de declaracin y asignacin de un int

int entero;

entero=13784;

// Ejemplo de declaracin y asignacin de un long int

long entero_largo;
entero_largo=57382L;

Como he mostrado en el ejemplo, a las constantes numricas de tipo long, se les

aade despus del nmero una L, de otra forma el nmero se supone de tipo int
(que son constantes que se pueden utilizar con char, short e int indistintamente,
aunque si son ms grandes de lo que el tipo de destino puede almacenar, el
nmero se truncar(8))

float, double y long double:

Estos tipos son los que nos permiten utilizar nmeros en coma flotante (nmeros
reales), tales como 3.141592654, 2.5, etc.

Entre ellos slo se diferencian en la precisin que nos dan y en la forma de poner
las constantes de dichos nmeros. Como regla general, para los nmeros en los
que basten con 6 dgitos de precisin, utilizaremos float, para los que
necesitemos 12 dgitos, utilizaremos double, y si necesitamos ms, utilizaremos
long double.

Las constantes numricas se escriben utilizando un punto para separar la parte

entera de la parte decimal o farccionaria, y si lo ponemos en forma cientfica,
utilizando una e minscula (e) o mayscula (E) para separar el nmero del
exponente. Ejemplos de nmeros as puestos seran: 10.5, 124.0, 15.4e15 (este
ltimo nmero sera 15.4*(10**15), si el asterisco-asterisco (**) fuera el smbolo
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 cul de los tipos de nmero en coma
flotante corresponde ese nmero:

Sufijo Tipo Ejemplo

f, F float 10.3e5f

(nada) double 12.6e4

l, L long double 1.54e10l

Unos ejemplos de declaracin y asignacin de nmeros en coma flotante seran:

// Ejemplo de declaracin y asignacin de un float

float numerof;

numerof=3.1415f;
// Ejemplo de declaracin y asignacin de un double

double numerod;

numerod=143e5;

// Ejemplo de declaracin y asignacin de un long int

long double numerold;

numerold=4.53564e12L;

Y esos son todos los tipos que tenemos disponibles de serie. Haba comentado
al principio que el C++ nos permite definir nuevos tipos y las operaciones entre
ellos, de manera que estn igual de integrados con el sistema que los de serie. Si
has echado en falta un tipo de dato para nmeros complejos, no te preocupes,
porque en C++ est soportado mediante una clase (en la librera estndar de
clases) que se llama complex y que est definida en complex.h. En lo nico que
se diferencia su uso del de los nmeros en coma flotante es en la manera de
definir un nmero complejo, que es por medio de constructores(9), los cuales
veremos en su momento.

Nos faltan por ver slo dos cosas respecto a la declaracin de variables: que se
pueden asignar valores a las variables en su declaracin y que se pueden declarar
varias variables del mismo tipo a un tiempo.

ASIGNACION DE VALORES A LAS VARIABLES EN SU DECLARACION

A esto tambin se lo denomina inicializacin de variables en la declaracin. La

asignacin de un valor a una variable cuando la declaramos es muy sencilla.
Basta con poner detrs del nombre de la variable un igual (=) y el nmero 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
declaracin, poniendo el tipo de las variables, y despus 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 seccin con todo esto que hemos
visto:

===[declvar2.cpp]===

/*

* declvar2.cpp

* Ejemplo de declaracin y asignacin 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 crculo 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 nmero.

slo se pueden utilizar carcteres ASCII (<=127), con lo que nos tenemos que
olvidar de nuestra querida y , as como de poner acento grfico (tilde) a las
vocales (no podemos utilizar tampoco ).

No se pueden utilizar los smbolos 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 ms sencillo es limitarse a las letras maysculas y

minsculas anglosajonas, as como los nmeros y el carcter de subrayado (_),
teniendo en cuenta que no podemos empezar el nombre de una variable con un
nmero.

EJERCICIOS

1.- Pon un ejemplo de una declaracin con inicializacin de cada uno de los tipos
de variables que hemos visto.

2.- Di si cada uno de los siguientes nombres seran vlidos para ser nombre de
una variable:

notacin for hola

nios 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 ms
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 slo se pueden
declarar las variables locales al principio del bloque (detrs del abrir-llave ({) o
detrs de otra declaracin).

(2) Esta definicin 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 anloga al char, slo que en este
caso sus constantes se expresan con una L mayscula delante, seguida de dos
letras entre comilla simple (') como por ejemplo en L'ab'

(4) En la mayora 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
opcin 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 smbolo <= para representar menor o igual.

(7) Los nmeros mgicos eran nmeros 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 tambin ayudan a evitar los nmeros mgicos

(8) En C/C++ los nmeros enteros se truncan a nivel de bits. As, si se asigna a
una variable de 16bits un dato de 32bits, en la variable slo se guardarn los 16
bits menos significativos del dato. El C++ es un lenguaje tipado, al contrario que
el C (que no protestaba cuando se introduca in int en vez de un char, por
ejemplo: el C haca silenciosamente la conversin 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 podra ser dar un char a una
funcin en vez de un int, o dar un nmero sin signo en vez de uno con signo. Eso
se hace por medio de la conversin 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 nmeros 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 declaracin, se pone justo despus
del nombre de la variable: complex numero(5,6); Dicho as quizs 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 ms adelante.

=== } /*cpp_4.txt*/ ===

Es increble que hayas llegado hasta aqu abajo :-b. Pero ya que lo has hecho,
recordarte que las variables son uno de los dos pilares bsicos para la
programacin 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 bsico }:).