Versión 2.

0
Acerca del Autor

Capítulo 1 Introducción a C++

Capítulo 2 Las partes de un programa de C++

Capítulo 3 Variables y Constantes

Capítulo 4 Expresiones y Secuencias

Capítulo 5 Funciones

Capítulo 6 Clases

Capítulo 7 Secuencias de control

Capítulo 8 Punteros

Capítulo 9 Referencias

Capítulo 10 Herencias

Capítulo 11 Arreglos o Matrices

Capítulo 12 Polimorfismo

Capítulo 13 Clases especiales y Funciones

Capítulo 14 Cadenas de caracteres

Capítulo 15 Comentarios Finales

Capítulo 16 Bibliografía y Agradecimientos

Capítulo 17 El Fin
 Acerca del Autor
Mi Nombre es Alvaro Tejada, soy de Lima, Perú, tengo 25 años
y junto con mi novia Milly, estudio Computación e Informática
en Cibertec, y curso el Quinto Ciclo. Soy experto de la
categoría de programación en Xpertia, bajo el pseudónimo de
Blag. Y dueño de mi propia "compañía" (Ficticia por el momento)
desarrolladora de software multimedia, SinglePath games design.
Mis inicios en la programación datan aproximadamente del año 1991, cuando
vivía en el DF, en México. Allí lleve un curso de introducción al Pascal,
aunque claro, en esos tiempos a pesar de que me llamaban la atención las
computadoras, no tenía claro que quería hacer. Fue recién cuando vi por
primera vez el juego Mortal Kombat de Midway que decidí que quería ser
programador. En ese entonces tenía, si no me equivoco, una Macintosh Plus
con Think Pascal. Para ser sinceros, no entendía nada y el único programa
que logré hacer fue uno que venía como ejemplo en el manual de usuario y
que nunca pude modificar. Luego el tiempo pasó y en el año 1997 ingresé a la
Universidad de Lima en la cual llevé el curso de "Técnicas de Programación
I", en el cual tuve mi primer contacto con C++, aunque aún no con los
resultados que yo esperaba (Siempre la programación es difícil al principio).
Fue a principios de 1998, en febrero más o menos, que mi papá me compró
un libro de Visual Basic "Visual Basic 6 Bible" y uno de C++ "Teach Yourself
C++ in 21 Days". Y así comencé mi carrera en el mundo de la programación.
No voy a negar que al principio me costó bastante y que mis primeros
programas eran bastantes simples, pero sentía la satisfacción de haberlos
hecho yo mismo.

El tiempo pasaba y me retiré de la Universidad de Lima, para ingresar a

Cibertec, en donde conocí por primera vez lo que era el lenguaje "Java". Ya
una vez que mis conocimientos de programación habían aumentado, y mis
programas y juegos mejorado, decidí explorar otros lenguajes de
programación, como Visual C++, Euphoria, Visual FoxPro, QBasic,
SQLServer, VBA, JavaScript, HTML, dBase III plus y Pascal.
Actualmente, trabajo como Consultor SAP. Hasta ahora he desarrollado
cerca de 32 programas y 10 juegos en distintos lenguajes, los cuales pueden
descargarse gratuitamente de SinglePath games design.

La idea de escribir un libro de programación la tuve porque como

programador autodidacta, he leído muchísimos libros y tutoriales, y pensé
que tal vez podía dar una pequeña contribución, espero que les guste y
escríbanme si tienen alguna duda, queja o comentario.
 Capítulo 1 - Introducción a C++

El lenguaje de programación C++ es uno de los lenguajes llamados de alto

nivel, porque una sola de sus instrucciones equivale a millares de código de
máquina.
C++ es un lenguaje de programación creado por Bjarne Stroustrup, hecho en
base al famoso y comercial lenguaje C. Cuyas capacidades fueron extendidas
para convertirlo en un lenguaje orientado a objetos. La cual es la
metodología de programación más difundida y utilizada actualmente.
Por último, solo queda mencionar que C++ es un lenguaje robusto y ha
demostrado con el pasar del tiempo de que es un lenguaje que debe ser
aprendido por cualquier persona que quiere programar y tiene cierta base,
porque además de bueno, el lenguaje C++, es uno de los más difíciles de
aprender.
Bueno, después de esta breve introducción, podemos pasar al capítulo 2 "Las
partes de un programa en C++".
Capítulo 2 - Las partes de un programa en C++

Para comenzar, tenemos el formato general de un programa hecho en C++:

#include <iostream.h>
#include <conio.h>

int main()
{
clrscr();
cout<<"Hola Mundo";
getch();
}

Aquí esta su explicación punto por punto:

#include <iostream.h> --> Librería necesaria para cout.

#include <conio.h> --> Librería necesaria para getch() y clrscr();

int main() --> Rutina o función principal

{ -->Determina donde empieza el código a ejecutar

clrscr(); -->Borra el contenido de la pantalla

cout<<" "; --> Escribe en la pantalla

getch(); --> Hace una copia de la pantalla

} -->Indica que el código terminó

Una parte importante de todo código de programación son los
comentarios:

Los comentarios, son partes del código que sirven como referencia para
otros programadores que desean modificar el código fuente. Además, si un
día formulas un código complejo, a los tres meses podrías no saber como
funciona, pero si lo has comentado no tendrás problemas.
Los comentarios son de dos tipos:

* // --> Comenta una línea

* /* */ --> Comenta un bloque de código, de varias líneas

Aquí hay un pequeño ejemplo:

#include <iostream.h>
#include <conio.h>

int main()
{
/*Este es un comentario
continúa hasta que se cierre
el slash*/
clrscr();
cout<<"Hola Mundo";
//Este es otro tipo de comentario, que solo comenta una línea
getch();
}
 Capítulo 3 - Variables y Constantes
Que es una Variable:

En C++, una variable es un lugar para guardar información, es un espacio en

memoria que guarda datos por un periodo determinado de tiempo. Hay dos
tipos, unsigned y signed. Todas las variables son signed por default(Signed
incluye negativos).

Tipos de Variables:

Bool -->Verdadero o Falso

unsigned short int -->0 a 65,535
short int -->-32,768 a 32,767
unsigned long int -->0 a 4,294,967,295
long int -->-2,147,483,648 a 2,147,483,647
int -->-32,768 a 32,767
unsigned int -->0 a 65,535
char -->256 caracteres
float -->1.2e-38 a 3.4e38
double -->2.2e-308 a 1.8e308

Definiendo una Variable:

Para declarar una variable, primero debe escogerse su tipo, ya sea int, long,
o short int. Luego, hay que darle un nombre que, sea de preferencia
relacionado con la función que va a realizar. Las variables deben ser
llamadas tal como han sido declaradas. Edad no es lo mismo que EDAD o que
EdaD. Por ejemplo:

#include<iostream.h>
#include<conio.h>

int main()
{
unsigned short clases;
long total;
int alumnos;
total=clases*alumnos;
//cout<<”El total es: “<<total;
getch();
}

Creando más de una variable a la vez:

Se puede declarar más de una variable a la vez, separandolas por comas:

#include<iostream.h>
#include<conio.h>

int main()
{
unsigned int miEdad,tuEdad;
long Dia,Mes,Anho;
getch();
}

Asignando valores a las variables:

Para asignarle valores a una variable, se utiliza el símbolo "=":

#include<iostream.h>
#include<conio.h>

int main()
{
unsigned short clases=5;
long total;
int alumnos=25;
total=clases*alumnos;
getch();
}
Otro ejemplo:

#include<iostream.h>
#include<conio.h>

int main()
{
unsigned short int Ancho=5,Largo;
Largo=10;

unsigned short int Area=(Ancho*Largo);

cout<<"Ancho:"<<Ancho<<"\n"; // "\n" Sirve para bajar una línea.

cout<<"Largo:"<<Largo<<"\n";
cout<<"Area:"<<Area<<"\n";
getch();
}

Usando typedef:

typedef, es un comando que te permite crear un alias para la declaración de

funciones, esto es, que puedes crear un alias para unsigned short int y
evitar tener que escribirlo cada vez que lo necesites.

#include<iostream.h>
#include<conio.h>
typedef unsigned short int USHORT;
int main()
{
USHORT Ancho=5;
USHORT Largo=2;
USHORT Area=Ancho*Largo;
cout<<"Area: "<<Area<<endl; //endl, cumple la función de "\n"
getch();
}
Caracteres especiales:

* "\n" --> Nueva Línea

* "\t" --> Tab o espacio
* "\b" --> Backspace o retroceder una línea
* "\"" --> Comilla doble
* "\'" --> Comilla simple
* "\?" --> Signo de interrogación
* "\\" --> backslash

Constantes:

Al igual que las variables, las constantes guardan información, pero a

diferencia de ellas, esta información no puede ser modificada.

Constantes Literales:

Una constante literal, es un valor ingresado directamente en tu programa,

en cualquier lugar que lo necesite.

int miEdad=23;

miEdad es una variable de tipo int (Entero); 39 es una constante literal. No

puedes asignar un valor a 39 y su valor no puede cambiarse

Constantes Simbólicas:

Una variable simbólica, es una variable que está representada por un

nombre, tal como una variable está representada. A diferencia de una
variable, sin embargo, su valor no puede ser modificado.

Estudiantes = clases * estudiantesporclase;

clases y estudiantesporclase son variables simbólicas. En cada lugar que el

programa lea estudiantes, asignará el valor de clases*estudiantesporclase.
Definiendo constantes con "const":

Utilizar const es muy útil, ya que se le puede dar un tipo a las variable y
volverla constante.

const unsigned short int estudiantesporclase=15;

Constantes Enumeradas:

Las constantes enumeradas, te permiten crear nuevos tipos y luego definir

dichas variables con valores que están restringidos a un grupo de posibles
variables.

enum COLOR {ROJO,AZUL,VERDE,BLANCO,NEGRO};

COLOR es el nombre de la enumeración, en otras palabras, un nuevo tipo.

ROJO es una variable simbólica con el valor "0", AZUL="1", etc.
Se pueden inicializar con el valor que uno elija.
{ROJO=100,AZUL,VERDE=500};

Ejemplo:

#include<iostream.h>
#include<conio.h>

int main()
{
enum Dias {Domingo,Lunes,Martes,Miercoles,Jueves,Viernes,Sabado};
int opcion;
cout<<"Ingresa un día (0-6): ";
cin>>opcion;
if(opcion==Domingo || opcion==Sabado)
cout<<"Ya estás en el fin de semana";
else cout<<"\nTodavía sigues en clases";
getch();
}
 Capítulo 4 - Expresiones y Secuencias

Que son Secuencias:

En C++, una secuencia controla la ejecución, evalúa una expresión, o no hace

nada.

x = a + b;

A diferencia del algebra, en la cual x sería igual a a + b, en C++, x obtendrá

el valor de la suma de a + b.

Bloques y Secuencias compuestas:

En cualquier lugar que puedas poner una secuencia, puedes poner una
secuencia compuesta. Una secuencia compuesta, ejecuta una serie de
expresiones. Comienza con una { y termina con una }.

{
temp=a;
a=b;
b=temp;
}

Expresiones:

Una expresion debe devolver un valor, por lo tanto 3+2 devuelve el valor 5.
Todas las expresiones son sequencias.
3.2 //Devuelve el valor 3.2
PI //Devuelve el valor 3.14
SegundosPorMinuto //Constante entera que devuelve el valor 60

Operadores:

Un operador es un símbolo que obliga al compilador a tomar una acción.

Operador de Asignación:

El operador de asignación provoca que la variable izquierda tome el o los

valores de las variables derechas.

x = a + b;
z = 10 - x;

Operadores Aritméticos:

Existen cinco operadores matemáticos: suma(+),resta(-),multiplicación(*),

división(/) y módulo(%).

x = 5 + 5; //10
y = 10 – 8; //2
z = 6 * 4; //24

División Entera y Módulo:

La división entera, toma solamente la parte entera de la división. La división

de módulo, toma solamente el residuo de la división.

x = 10 / 5; //2
y = 10 % 5; //0
z = 6 % 4 ; //2

Incremento y Decremento:

El operador incremento (++) eleva el número en un dígito. El operador

decremento (--) lo decrementa en un dígito.

c++;
c = c + 1;
//Son equivalentes
Prefix y Postfix:

El prefix se escribe antes del nombre de la variable, e incrementa el valor y

luego lo asigna. El postfix se escribe después de la variable, y asigna el valor
y luego lo incrementa.

int a = ++x; //Prefix

int b = x++; //Postfix

Otro ejemplo:
#include <iostream.h>
#include <conio.h>

int main()
{
int miEdad = 23;
int tuEdad = 23;
cout<<"Yo tengo: "<<miEdad<<" años de edad.\n";
cout<<"Tu tienes: "<<tuEdad<<" años de edad.\n";
miEdad++;
++tuEdad;
cout<<"Un año pasó...\n";
cout<<"Yo tengo: "<<miEdad<<" años de edad.\n";
cout<<"Tu tienes: "<<tuEdad<<" años de edad.\n";
cout<<"Un año pasó...\n";
cout<<"Yo tengo: "<<miEdad++<<" años de edad.\n";
cout<<"Tu tienes: "<<++tuEdad<<" años de edad.\n";
cout<<"Escribamoslo de nuevo.\n"; cout<<"Yo tengo: "<<miEdad<<" años de
edad.\n";
cout<<"Tu tienes: "<<tuEdad<<" años de edad.\n";
getch();
}
Operadores Relacionales:

Son usados para determinar cunado dos números son iguales o si uno es
mayor que el otro:

Igualdad == 100==50 falso

Desigualdad != 100!=50 verdadero
Mayor que > 100>50 verdadero
Mayor igual que >= 100>=50 verdadero
Menor que < 100<50 falso
Menor igual que <= 100<=50 falso

El operador IF:

Este operador examina una condición dada y ejecuta una acción

determinada:

#include <iostream.h>
#include <conio.h>
int main()
{
int miNum=5,tuNum;
cout<<"Ingresa un número:";
cin>>tuNum;
if(tuNum>miNum)
cout<<"\nGanaste, tu número es mayor que el mio";
getch();
}
El operador ELSE:

Este operador es utilizado junto con IF, si la condición no se cumple se

ejecuta otra acción:

#include <iostream.h>
#include <conio.h>
int main()
{
int miNum=5,tuNum;
cout<<"Ingresa un número:";
cin>>tuNum;
if(tuNum>miNum)
cout<<"\nGanaste, tu número es mayor que el mio";
else
cout<<"Gané!, Mi número es mayor que el tuyo";
getch();
}

Cuándo usar llaves en IF-ELSE:

Por lo general, una simple instrucción IF-ELSE, no necesita llaves, pero

cuando las instrucciones que va a ejecutar son mayores de una línea o hay IF
dentro de otros IF, debes utilizar llaves para evitar la confución y el código
pueda ejecutarse:

#include <iostream.h>
#include <conio.h>
int main()
{
int miNum=5,tuNum;
cout<<"Ingresa un número:";
cin>>tuNum;
 if(tuNum>miNum){
cout<<"\nGanaste, tu número es mayor que el mio\n";
cout<<"Que te parece si empezamos otra vez";
}
else{
if(tuNum<1)
cout<<"El cero y los números negativos no juegan!";
else
cout<<"Gané!, Mi número es mayor que el tuyo";
}
getch();
}

Operadores Lógicos:

Los operadores lógicos son usados para concatenar operadores relacionales:

AND && expresión1 && expresión2

OR ||(alt+124) expresión1 || expresión2
NOT ! !expresión1

AND:

Sólo es verdadero cuando ambas expresiones son verdaderas:

if((5==5) && (8==8))

OR:

Basta que una expresión sea verdadera para que sea verdadero:

if((5==5) || (6==8))

NOT:

Si es verdadera, la vuelve falsa y viceversa

if(5!=5) ó if(!(x==5))
El operador condicional(Ternario):

Es un IF-ELSE automático:

(expresión1)?(expresión2):(expresión3)

Si la expresión1 es verdadera, devuelve el valor de la expresión2, si es falsa,

devuelve el valor de la expresión3.

#include <iostream.h>
#include <conio.h>
int main()
{
int x,y,z;
cout<<"Ingresa dos números.\n";
cout<<"Primero: ";
cin>>x;
cout<<"Segundo: ";
cin>>y;
if(x>y)
z=x;
else
z=y;
cout<<"z: "<<z;
z=(x>y)?x:y; //Operador Ternario
cout<<"z: "<<z;
getch();
}
 Capítulo 5 - Funciones
¿Qué es una función?

Una función es un subprograma que puede interactuar con los datos y

devolver un valor (solamente un valor).
Las funciones pueden devolver un valor (int,long,float) o no devolver nada
(void), además pueden recibir parámetros con los cuáles interactuar (int,
char,long) o no recibir ninguno.

unsigned short int EncontrarArea(int largo, int ancho);

----------------- ------------ --------------------
Tipo que retorna Nombre Parámetros que recibe

Ejemplo de una función

#include <iostream.h>
#include <conio.h>

int Area(int largo, int ancho) //Prototipo de la función

{
return largo * ancho;
}

int main()
{
int largoTerreno, anchoTerreno, areaTerreno;
clrscr();
cout<<"\nQue tan ancho es tu terreno? ";
cin>>anchoTerreno;
cout<<"\nQue tan largo es tu terreno? ";
cin>>largoTerreno;

areaTerreno=Area(largoTerreno,anchoTerreno);
cout<<"\Tu terreno tiene ";
cout<<areaTerreno;
cout<<" pies cuadrados\n\n";
getch();
}

Variables Locales y Globales

Las variables pueden estar definidas en dos capas diferentes de un

programa, las variables locales, pertenecen a una función y solo puden ser
modificadas o utilizadas por este, ya que al terminar la función, su valor
desaparece. Las variables globales en cambio, pueden ser utilizadas por
cualquier función o método del programa, lo cual las hace peligrosas, porque
cualquiera puede cambiar su valor.

Ejemplo de variables locales y locales

#include <iostream.h>
#include <conio.h>

int altura,peso; //Variables Globales

int Edad(int edad) //Prototipo de la función

{
return edad; //Una función un poco inservible
}
int main()
{
clrscr();
int edad,nedad; //Variable Local
cout<<"Cual es tu altura?";
cin>>altura;
cout<<"Cual es tu peso?";
cin>>peso;
cout<<"Cual es tu edad?";
cin>>edad;
nedad=Edad(edad);
cout<<"Tu altura es "<<altura;
cout<<" Tu peso es "<<peso;
cout<<" y tu edad es "<<nedad;
getch();
}
 Capítulo 6 - Clases
¿Qué es una clase?

Una clase es una declaracion que sirve como un contenedor para nuevas
variables creadas por nosotros mismos.
Las clases pueden representar situaciones o elementos de la vida real, lo
cual nos ayuda a elaborar mejores programas y que son por ende más fáciles
de mantener y actualizar. Cada elemento que forma la clase, es llamado
Objeto.

Ejemplo de una clase

class Estudiante
{
unsigned int codigo;
unsigned int edad;
void Comentarios();
}

Definir un objeto

Los objetos se declaran de la misma manera en que se declararia una

variable normal.

Estudiante Alvaro; //Variable Alvaro de tipo Estudiante.

Acceder a los miembros de las clases

Alvaro.codigo = 108;
Alvaro.edad = 24;

Miembros Privados y Miembros Públicos

Todos los miembros de una clase, son privados por default, es decir, que si
no se especifica lo contrario, van a ser privados.
Para poder acceder y asignar valores a los miembros de la clase, estos
deben ser publicos.
#include <iostream.h>
#include <conio.h>

class Estudiante
{
public:
unsigned int codigo;
unsigned int edad;
void Comentarios();
};

int main()
{
Estudiante Alvaro;
Alvaro.edad = 24;
cout<<"El estudiante Alvaro, tiene "<<Alvaro.edad<<" años";
getch();
}

Conservar algunos datos como Privados

Para un mejor control del programa, se deben dejar algunos datos como
privados y crear funciones que accesen a ellos y nos permitan trabajar.

#include <iostream.h>
#include <conio.h>

class Estudiante
{
public:
unsigned int gCodigo();
void sCodigo(unsigned int Cod);

unsigned int gEdad();

 void sEdad(unsigned int Ed);

void Comentarios();

private:
unsigned int Codigo;
unsigned int Edad;
};

* Para acceder a estos datos y modificarlos se utiliza lo siguiente:

Estudiante Alvaro;
Alvaro.sCodigo(108);

Implementando los metodos de la clase

A continuación está un ejemplo de como implementar nuestra clase

Estudiante.

#include <iostream.h>
#include <conio.h>

class Estudiante
{
public:
unsigned int gCodigo();
void sCodigo(unsigned int Cod);
void Comentarios();

private:
unsigned int Codigo;
};
unsigned int Estudiante::gCodigo()
{
return Codigo;
}

void Estudiante::sCodigo(unsigned int Cod)

{
Codigo = Cod;
}

void Estudiante::Comentarios()
{
cout<<"Alvaro Tejada. Programador\n";
}

int main()
{
Estudiante Alvaro;
Alvaro.sCodigo(108);
cout<<"El código de Alvaro es: "<<Alvaro.gCodigo()<<"\n";
Alvaro.Comentarios();
getch();
}

Constructores y Destructores

Para inicializar algún miembro de alguna clase, se utiliza un constructor, los

constructores pueden recibir parámetros, pero no pueden retornar ningún
valor, ni siquiera Void. Este constructor, debe tener el mismo nombre que la
clase.
Luego de haber declarado el constructor, debes declarar un destructor,
para que libere la memoria utilizada. los destructores siempre tienen el
nombre de la clase antepuestos por el símbolo ~ (alt+126), los destructores,
no reciben argumentos, y tampoco retornan un valor.
#include <iostream.h>
#include <conio.h>

class Estudiante
{
public:
Estudiante(int Codigo);
~Estudiante();
unsigned int gCod();
unsigned int sCod(int cod);
void Comentarios();
private:
unsigned int vCod;
};

//Constructor
Estudiante::Estudiante(int Codigo)
{
vCod = Codigo;
}

//Destructor
Estudiante::~Estudiante()
{
}

unsigned int Estudiante::gCod()

{
return vCod;
}
unsigned int Estudiante::sCod(int cod)
{
vCod = cod;
}

int main()
{
clrscr();
Estudiante Alvaro(108);
cout<<"El código de Alvaro es: "<<Alvaro.gCod();
Alvaro.sCod(250);
cout<<"\nEl nuevo código de Alvaro es: "<<Alvaro.gCod();
getch();
}

Estructuras

En realidad, las estructuras y las clases cumplen la misma función, por lo

cual, pueden reemplazarse los comandos "class" por "struct". La diferencia
basica es que en las Estructuras, los miembros son públicos por default.
Este es solo un accidente histórico, en el paso de C a C++.
 Capítulo 6 - Secuencias de Control
¿Qué son las secuencias de control?

La secuencias de control, son métodos o funciones, que nos permiten

ejecutar una instrucción más de una vez, o por un número ilimitado de veces
o hasta que se cumpla una condición dada.
Para mi punto de vista, este es uno de los puntos más importantes, ya que
casi todos o todos los lenguajes de programación los utilizan, aunque no por
eso, significa que no sean fáciles de aprender y utilizar.

While o Mientras

While o Mientras(En pseudo-código), permite ejecutar una instrucción o un

conjunto de instrucciones mientras la condición dada sea verdadera.

#include <iostream.h>
#include <conio.h>

int main()
{
int counter=0;

while(counter<5) //Mientras counter sea menor a 5

// ejecuta la instrucción.
{
counter++; //Aumenta a counter en uno.
cout<<"Hola\n";
}
getch();
}
#include <iostream.h>
#include <conio.h>

int main()
{
clrscr(); //Para borrar la pantalla.
int num;
cout<<"Ingresa un número del 1 al 10: ";
cin>>num;
while(num>0 && num<11) //Mientras num sea mayor a 0 y menor que 11
{
cout<<"\nTu número es num: "<<num;
num++;
}
getch();
}

Do...While o Hacer...Mientras

Do...While o Hacer...Mientras(En psudo-código). Aunque es similar al While,

el Do...While, tiene la ventaja de que ejecuta las instrucciones antes de
verificar si la condición se cumple, por lo cual, siempre se ejecutará por lo
menos una vez.

#include <iostream.h>
#include <conio.h>

int main()
{
clrscr(); //Para borrar la pantalla.
int num;

cout<<"Ingresa un número del 1 al 10: ";

cin>>num;
do //Hacerlo una vez
{
cout<<"\nTu numero es num: "<<num;
num++;
}while(num>0 && num<11); //Y verificar si num es mayor a 0
//y menor que 11
getch();
}

For o Para

El For o Para(En psudo-código), se utiliza para asignar un valor, verificar una

condición y aumentar la variable, todo en una sola línea.

#include <iostream.h>
#include <conio.h>

int main()
{
clrscr(); //Para borrar la pantalla.
int num;
for(num=0;num<6;num++)
cout<<"\nEl número es: "<<num;
getch();
}

Switch o Casos

El Switch o Casos(En pseudo-código), permite escoger entre una amplia

gama de posibilidades, sin tener que ejecutar millones de líneas de if, else,
etc.
Es muy útil a la hora de generar menues, que piden al usuario, escoger una
opción.

#include <iostream.h>
#include <conio.h>
int main()
{
clrscr();
int opcion;
do
{
cout<<"1)\n";
cout<<"2)\n";
cout<<"3)\n";
cout<<"Escoja una opción: ";
cin>>opcion;
}while(opcion<0 || opcion>4); //si opcion es menor que 0 ó mayor que 4

switch(opcion) //Verifica el valor de opcion

{
case 1: //Si es uno
cout<<"Eligio la opción 1";
break; //El break sirve para que no ejecute
//las demas opciones.
case 2: //Si es dos
cout<<"Eligio la opción 2";
break;
case 3:
cout<<"Eligio la opción 3";
break;
default:
cout<<"Esa no es una opción valida";
break;
}
getch();}
 Capítulo 7 - Punteros
¿Qué son los punteros?

Un puntero es una variable que guarda una dirección de memoria.

En realidad este no es un punto que domino, porque en realidad es bastante
complicado sobre todo para los principiantes en programación, de todos
modos, trataré de explicarlos de la mejor manera posible.

Ejemplo de las Direcciones de Memoria

Cada variable está asignada a un espacio en memoria determinado, con los

punteros, nosotros podemos especificar en que espacio de memoria localizar
nuestras variables.

#include <iostream.h>
#include <conio.h>

int main()
{
unsigned short shortVar = 5;

cout<<"shortVar: "<<shortVar;
cout<<"Direccion de shortVar: "<<&shortVar;
getch();
}

/*El símbolo & delante del shortVar, nos dá la dirección que tiene
en memoria shortVar*/

¿Cómo guardar esa dirección en un Puntero

Como mencioné, toda variable declarada tiene una dirección en memoria, y

esta puede ser almacenada en un puntero.
int howMany = 8; //Creamos e inicializamos una variable
int * pMany = 0; //Creamos e inicializamos un puntero, lo más
//recomendable, es siempre comenzar inicializandolo con cero, para
//evitar crear un Wild o Stray Pointer.
pMany = &howMany; //Se le asigna al puntero, la dirección de la variable.

//También se puede declarar e inicializar al mismo tiempo.

int howMany = 8;
int * pMany = &howMany;

Para que usar Punteros

Los punteros son muy usados, para manejar datos en el área libre de
memoria, acceder a datos y funciones de clases, pasar variables por
referencia a las funciones, etc.

Operador New

El operador New, se utiliza para crear un objeto en el área libre de

memoria. El resultado del operador New, es una dirección de memoria que
debe ser asignada a un puntero. Más adelante veremos para que nos sirve
esto exactamente

unsigned long int * pPointer; //Se declara el tipo del puntero

pPointer = new unsigned long int; //Se crea en la memoria libre

*pPointer = 77; //Se le asigna un valor

El operador Delete

Cuando terminas de utilizar un puntero, debes regresarlo al área libre de

memoria, esto se hace utilizando el operador Delete. Los punteros no se
eliminan automaticamente y puden provocar una perdida innecesaria de
memoria.

delete pPointer;
Ejemplo

#include <iostream.h>
#include <conio.h>

int main()
{
int lVal = 8;
int * pLocal = &lVal;
int * pStore = new int;
*pStore = 5;
cout<<"lVal: "<<lVal<<"\n";
cout<<"*pLocal: "<<*pLocal<<"\n";
cout<<"*pStore: "<<*pStore<<"\n";
delete pStore;
pStore = new int;
*pStore = 3;
cout<<"*pStore: "<<*pStore<<"\n";
delete pStore;
getch();
}

Creando y Eliminando Objetos en el área libre de memoria

Los objetos en el área libre de memoria, se crean de la misma manera que

las variables, se crean, se inicializan y se se asignan.
Cada vez que se llama al operador New sobre un objeto, se llama al default
constructor y cuando se ua el operador delete, se llama al destructor.
#include <iostream.h>
#include <conio.h>
class Estudiante
{
public:
Estudiante();
~Estudiante();
private:
int vCod;
};
Estudiante::Estudiante()
{
cout<<"LLamando al constructor.\n";
vCod = 108;
}

Estudiante::~Estudiante()
{
cout<<"LLamando al destructor.\n";
}

int main()
{
cout<<"Estudiante Alvaro...\n";
Estudiante Alvaro;
cout<<"Estudiante *pSid = new Estudiante...\n";
Estudiante *pSid = new Estudiante;
cout<<"delete pSid...\n";
delete pSid;
cout<<"Terminando la demostración...\n";
getch();
}
Accesando a los miembros de Datos

Para poder acceder a los miembros de datos de un objeto creado en al área

libre de memoria, se debe utilizar al operador ->.

#include <iostream.h>
#include <conio.h>

class Estudiante
{
public:
Estudiante() {vCode = 108;} //Declaración con función en línea.
~Estudiante() {}
unsigned int gCode() const {return vCode;} //Al ser constante, no se
//puede modificar
void sCode(unsigned int cod) {vCode = cod;}
private:
unsigned int vCode;
};

int main()
{
Estudiante * pAlvaro = new Estudiante;
cout<<"El código de Alvaro es: "<<pAlvaro->gCode();
pAlvaro->sCode(205);
cout<<"El nuevo código de Alvaro es: "<<pAlvaro->gCode();
delete pAlvaro;
getch();
}
#include <iostream.h>
#include <conio.h>

class Estudiante
{
public:
Estudiante();
~Estudiante();
unsigned int gCode() const {return *vCode;}
void sCode(unsigned int cod) {*vCode = cod;}
private:
unsigned int *vCode;
};

Estudiante::Estudiante()
{
vCode = new unsigned int(108);
}

Estudiante::~Estudiante()
{
delete vCode;
}

int main()
{
Estudiante * Alvaro = new Estudiante;
cout<<"El código de Alvaro es: "<<Alvaro->gCode();
Alvaro->sCode(205);
cout<<"El nuevo código de Alvaro es: "<<Alvaro->gCode();
delete Alvaro;
getch();
}
 Capítulo 8 - Referencias
¿Qué son las referencias?

Las referencias son alias que se le pueden dar una variable, es como un
sobrenombre y todo lo que se le haga al alias le ocurrirá a la variable y
viceversa. Se reconocen porque al comenzar el nombre de la variable, se les
antepone el simbolo &.

Ejemplo de Creación y uso de Referencias

#include <iostream.h>
#include <conio.h>

int main()
{
int miNum;
int &rNewNum = miNum;

miNum = 14;
cout<<"miNum: "<<miNum<<"\n";
cout<<"rNewNum: "<<rNewNum<<"\n";

NewNum = 24;
cout<<"miNum: "<<miNum<<"\n";
cout<<"rNewNum: "<<rNewNum<<"\n";

getch();
}

referenciar Objetos

Al igual que las variables se pueden referenciar, los objetos de una clase
también.
#include <<iostream.h>
#include <<conio.h>

class Estudiante
{
public:
Estudiante(int code,int edad);
~Estudiante() {}
int gCode() {return vCode;}
int gEdad() {return vEdad;}
private:
int vCode;
int vEdad;
};

Estudiante::Estudiante(int code,int edad)

{
vCode = code;
vEdad = edad;
}

int main()
{
Estudiante Alvaro(108,24);
Estudiante & rAlv = Alvaro;

cout<<"El código de Alvaro es: "<<Alvaro.gCode();

cout<<"\ny su edad es: "<<rAlv.gEdad();

getch();
}
Retornando multiples valores

Como sabemos, una función solo puede retornar un valor, pero que pasa si
necesitamos retornar más de uno, talves dos o tres... Con las referencias
podemos hacerlo.

#include <iostream.h>
#include <conio.h>

int Potencias(int, int &, int &);

int main()
{
int numero,cuadrado,cubo;

cout<<"Ingresa un número positivo: ";

cin>>numero;

Potencias(numero, cuadrado, cubo);

cout<<"numero: "<<numero<<"\n";
cout<<"cuadrado: "<<cuadrado<<"\n";
cout<<"cubo: "<<cubo<<"\n";

getch();
}

int Potencias(int numero, int &rCuadrado, int &rCubo)

{
rCuadrado = numero*numero;
rCubo = numero*numero*numero;
}
Cuando usar Referencias y cuando Punteros

Las referencias no pueden ser reasignadas, tampoco pueden ser nulas. Por lo
general, recomiendo utilizar Referencias, porque son más sencillas y más
seguras, pero si cumple alguna de las dos limitaciones es necesario utilizar
punteros.
 Capítulo 9 - Herencia
¿Qué es la Herencia?

La herencia puede describirse como un concepto de la vida real, por

ejemplo, de los de los animales, podemos sacar a los mamiferos, de los
mamiferos a los gatos, y de los gatos a los gatos salvajes de las estepas
norafricanas y de estos últimos a mi gato "Cheko". Podemos decir que
"Cheko" desciende de toda esta línea de clasificaciones y por lo tanto debe
tener también sus caracteristicas, tanto de los gatos como de los
mamiferos. En las Herencias, las clases, heredan atributos y funciones de
otras clases que son superiores a ellas.

Ejemplo de Herencia

#include <iostream.h>
#include <conio.h>

class Mamiferos
{
public:
//Constructores
Mamiferos():vEdad(2),vPeso(4){}
~Mamiferos(){}

int gEdad() const {return vEdad;}

void sEdad(int Edad) {vEdad = Edad;}
int gPeso() const {return vPeso;}
void sPeso(int Peso) {vPeso = Peso;}

void Hablar() const {cout<<"Mamifero hablando\n";}

protected:
int vEdad;
int vPeso;
};
class Gato:public Mamiferos
{
public:
Gato() {}
~Gato() {}

void Dormir() const {cout<<"Gato durmiendo...\n";}

};

int main()
{
clrscr();
Gato Cheko;
Cheko.Hablar();
Cheko.Dormir();
cout<<"Cheko tiene "<<Cheko.gEdad()<<" años y pesa "<<Cheko.gPeso();
cout<<" kilos.";

getch();
}

Private contra Protected

Los miembros de datos de una clase que son declarados como Private, no
pueden ser accesados por las clases derivadas (En Herencia), por lo cual se
utiliza el comando Protected: , esto hace que los miembros de datos
continuen privados pero sean visibles para las clases derivadas.

Métodos Virtuales

Los métodos virtuales, sirven para poder tener metodos con nombre iguales,
tanto en la clase madre como en la clases derivada, sin que estos entren en
conflicto, el compilador sabe a cual llamar dependiendo del contexto,
también permiten la utilización de punteros, que declaren una clase derivada
como nueva instancia de la clase madre.
#include <iostream.h>
#include <conio.h>

class Mamiferos
{
public:
Mamiferos():vEdad(2) {cout<<"Constructor Mamiferos...\n";}
virtual ~Mamiferos() {cout<<"Destructor Mamiferos...\n";}
void Mover() const {cout<<"Mamiferos avanzan un paso\n";}
virtual void Hablar() const {cout<<"Mamiferos hablando\n";}
protected:
int vEdad;
};

class Gato:public Mamiferos

{
public:
Gato() {cout<<"Constructor Gato...\n";}
~Gato() {cout<<"Destructor Gato...\n";}
void Hablar() const {cout<<"Miau!\n";}
void Mover() const {cout<<"Gato avanza 3 pasos\n";}
};

int main()
{
Mamiferos *pGato = new Gato;
pGato->Mover();
pGato->Hablar();

getch();
}
as, tampoco
 Capítulo 10 - Arreglos o Matrices
¿Qué son los Arreglos o Matrices?

Los Arreglos o Matrices, pueden definirse com un conjunto de elementos,

oredenados por un índice que van del 0 al n-1. Se representan por: long
Numeros[5], donde, los índices van del 0 al 4.

Ejemplo de Arreglos o Matrices

#include <iostream.h>
#include <conio.h>

int main()
{
int Array[5],i;

for(i=0;i<5;i++)
{
cout<<"Ingresa valores para el Arreglo: ";
cin>>Array[i];
}
for(i=0;i<5;i++)
cout<<i<<": "<<Array[i]<<"\n";

getch();
}

Inicializando Arreglos o Matrices

Un Arreglo o Matriz, puede inicializarse tanto con varibles como por

caracteres, estando cada uno de ellos, separados por comas.

int Array[5] = {1,2,3,4,5};

int Array2[5] = {1,2,3};

Declarando Arreglos o Matrices

Los Arreglos o Matrices, pueden tener cualquier nombre, pero no el mismo

nombre que otra variable que ya haya sido declarada.

Arreglo o Matriz de Objetos

Al igual que las variables o caracteres, los objetos también pueden ser
almacenados en un arreglo o matriz.

#include <iostream.h>
#include <conio.h>

class Gato
{
public:
Gato() {vEdad = 2; vPeso = 4;}
~Gato() {}

int gEdad() const {return vEdad;}

int gPeso() const {return vPeso;}
void sEdad(int Edad) {vEdad = Edad;}
private:
int vEdad;
int vPeso;
};

int main()
{
Gato Gatitos[5];
int i;
for(i=0;i<5;i++)
Gatitos[i].sEdad(2*1+1);
 for(i=0;i<5;i++)
{
cout<<"\nGatito# "<<i+1<<" tiene: "<<Gatitos[i].gEdad()<<" años";
}
getch();
}

Arreglos o Matrices Multidimiensionales

Para entender esto, pensemos en un tablero de Ajedrez, tiene 8 filas por 8

columnas, un total de 64 casilleros, esto podría representarse de dos
maneras.

int Chess[64]; int Chess[8][8];

#include <iostream.h>
#include <conio.h>

int main()
{
int Array[2][2];
int i,j;
for(i=0;i<2;i++)
for(j=0;j<2;j++)
{
cout<<"Ingresa valores a la matriz: ";
cin>>Array[i][j];
}
for(i=0;i<2;i++)
for(j=0;j<2;j++)
{
cout<<"Los valores son["<<i<<"]"<<"["<<j<<"]:"
<<Array[i][j]<<"\n";
}
getch();}
Arreglos o Matrices de Punteros

Estos son utilizados para poder almacenar los objetos en el área libre de
memoria.

#include <iostream.h>
#include <conio.h>

class Gato
{
public:
Gato() {vEdad = 2; vPeso = 4;}
~Gato() {}

int gEdad() const {return vEdad;}

int gPeso() const {return vPeso;}
void sEdad(int Edad) {vEdad = Edad;}
private:
int vEdad;
int vPeso;
};

int main()
{
Gato * Gatitos[20];
int i;
Gato * pCheko;
for(i=0;i<20;i++)
{
pCheko = new Gato;
pCheko->sEdad(2*i+1);
Gatitos[i] = pCheko;
}
for(i=0;i<20;i++)
{
cout<<"Cheko# "<<i+1<<": "<<pCheko->gEdad();
}

getch();
}

Arreglos o Matrices de Caracteres

E C++, una palabra o cadena de caracteres, es realidad un arreglo o matriz

de caracteres, terminando con el símbolo de final de línea o '\0'.
Nosotros podemos declarar nuestra propia matriz o arreglo de caracteres.

#include <iostream.h>
#include <conio.h>

int main()
{
char cadena[20];
cout<<"Ingresa la cadena de caracteres: ";
cin>>cadena;
cout<<"\nAquí está la cadena de caracteres: "<<cadena;
getch();
}
 Capítulo 11 - Polimorfismo
¿Qué es el Polimorfismo?

Cuando hablamos de herencia, dijimos, que podiamos tomar una clase y

derivar otra de ella, haciendo que la clase derivada tomara las funciones y
atributos de la clase base o primaria. Pues bien, que pasa si tenemos dos
clases primaria y queremos que nuestra nueva clase derivada, derive de
ambas, es decir, herede los atributos y los métodos de las clases de las
cuales derivó. Por ejemplo, podemos tener la clase Caballo y la clase Ave, el
primero galopa y el segundo vuela, pero supongamos que queremos crear una
clase que derive de los dos, por ejemplo, un Pegaso, que puede cabalgar y
volar, en Herencia, esto no sería posible, y de serlo, nos obligaría a crear
varias instancias del mismo método, como en el caso de Volar(), que tendría
que estar tanto en Ave como en Pegaso, o tan solo podría hacer una de las
dos cosas, pues bien, con el Polimorfismo, podemos manejar que esas dos
clases bases se fusiones para la clase derivada que vamos a crear.

#include <iostream.h>
#include <conio.h>

class Caballo
{
public:
Caballo() {}
~Caballo() {}
virtual void Galopar() const {cout<<"El caballo galopa 2 pasos";}
};

class Ave
{
public:
Ave() {}
virtual ~Ave() {}
virtual void Volar() const {cout<<"El Ave Vuela 2 metros...";}
};
class Pegaso:public Caballo,public Ave
{
public:
Pegaso() {}
virtual ~Pegaso() {}
virtual void Galopar() const {cout<<"El pegaso Galopa 2 pasos";}
virtual void Volar() const {cout<<"El pegaso Vuela 2 metros...";}
};

int main()
{
clrscr();
int choice;
do
{
cout<<"(1)Caballo\n"<<"(2)Ave\n"<<"(3)Pegaso \n";
cin>>choice;
}while(choice<1 || choice>5);
if(choice==1)
{
Caballo * Horse = new Caballo;
Horse->Galopar();
}
else if(choice==2)
{
Ave * Bird = new Ave;
Bird->Volar();
}
else if(choice==3)
{
Pegaso * Pegasus = new Pegaso;
Pegasus->Galopar();
cout<<"\n";
Pegasus->Volar();
}
getch();
}

Conclusión

Como podemos ver, Pegaso hereda tanto de Caballo como de Ave, y por lo
tanto puede galopar y volar. Una prueba interesante para comprobar esto,
puede ser comentar los dos métodos de Pegaso, con lo cual se ve de manera
más clara que hereda ambos métodos.
comiendo utilizar Referencias, pero si cumple alguna de las dos limitaciones
es necesario utilizar punteros.
 Capítulo 12 - Clases especiales y Funciones

Miembros de Datos Estáticos

Los miembros de datos estáticos, son aquellos, que permanecen a lo largo de

todo el proceso de las instancias de la clase, están en contacto tanto con los
datos globales como con los objetos de la clases. En realidad pertenecen a
las clases y existen una por clase.

#include <iostream.h>
#include <conio.h>

class Gato
{
public:
Gato() {CuantosGatos++;}
virtual ~Gato() {CuantosGatos--;}
static int CuantosGatos;
};

int Gato::CuantosGatos = 0;

int main()
{
const int MaxGatos = 5;
int i;
Gato * Gatitos[MaxGatos];
for(i=0;i<MaxGatos;i++)
Gatitos[i] = new Gato;

for(i=0;i<MaxGatos;i++)
{
cout<<"\nQuedan: ";
cout<<Gato::CuantosGatos;
 cout<<" diciendo Miau!!!";
delete Gatitos[i];
Gatitos[i] = 0;
}
getch();
}
 Capítulo 13 - Cadenas de Caracteres

Miembros de Cin

get() sin parámetros

Este comando retorna el valor del caracter encontrado hasta que encuentre
el final del archivo. No se pueden concatenar varias instancias de
caracteres en el get() sin parámetros.

#include <iostream.h>
#include <conio.h>

int main()
{
char ch;
char = Hola;
while((ch=cin.get())!=EOF) //EOF, End of File.
{
cout<<"ch: "<<ch;
}
getch();
}

get() con parámetros

Cuando se utiliza el get() con parámetros, si es posible concatenar las

instancias de los caracteres.

#include <iostream.h>
#include <conio.h>

int main()
{
char a,b,c;
cout<<"Ingresa tres letras: ";
cin.get(a).get(b).get(c);
cout<<"a: \n"<<a<<" b: \n"<<b<<" c: "<<c;
getch();
}

peek() ,putback(), ignore()

peek() se utiliza para saber cual es el caracter que viene a continuación y

putback(), reemplaza el caracter siguiente por algún otro caracterer que
definamos. ignore(), ignora un caracter determinado, tomandolo como inicio
e ignorando en adelante de acuerdo al número especificado.

#include <iostream.h>
#include <conio.h>

int main()
{
char ch;
cout<<"Ingresa una cadena de caracteres: ";
while(cin.get(ch))
{
if(ch=='a')
cin.putback('$');
else
cout<<ch;
while(cin.peek()=='e')
cin.ignore(1,'e');
}
getch();
}
Miembros de Cout

width() y fill()

El objetivo de width(), es dejar espacio, de acuerdo al valor que le

entregemos, algo así como varios "\t". Funciona en relación con fill().
El objetivo de fill(), es rellenar espacios vacios con algún caracter que
determinemos.

#include <iostream.h>
#include <conio.h>

int main()
{
cout<<"Ejemplo: ";
cout.width(15);
cout.fill(‘$’);
cout<<""; //de width() y fill();
getch();
}

Flags

setf()

El comando setf(), se utiliza para poner flags o caracteriscticas al texto que

va a escribirse. Ya sea oct, hex, setfill(), etc.

#include <iostream.h>
#include <conio.h>
#include <iomanip.h>

int main()
{
const int num = 138;
cout<<"El número es: "<<num;
cout<<"El número es: "<<hex<<num;
cout<<"El número es: ";
cout.width(10);
cout.setf(ios::left);
cout<<oct<<num;

getch();
}

Lista de Modificadores

No necesitan iomanip.h

· flush: libera el buffer

· endl: agrega una nueva linea y libera el buffer
· oct: pone la base a octal
· dec: pone la base a decimal
· hex: pone la base a hexadecimal

Lista de Modificadores

Necesitan iomanip.h

· setbase(base): pone la base(0 = decimal, 8 = octal, 10 = decimal, 16 =

hex)
· setw(width): pone el mínimo tamaño del width
· setfill(ch): el caracter de relleno a utilizar con width
· setprecision(p): para números con coma flotante
· setiosflag(f): pone una o más flags del ios
· resetiosflag(f): resetea una o más flags del ios

Entrada y Salida de Archivos

Abriendo archivos para Lectura y Escritura

Para poder manipular archivos, es necesario crear un objeto "ofstream" y

luego asociarlo con algún archivo existente.
Para ello, debes incluir el archivo .
oftream fout("prueba.cpp") //Para escritura

ifstream fin("prueba.cpp") //Para Lectura

Ejemplo

#include <conio.h>
#include <stdio.h> //Para gets();
#include <fstream.h> //Para fout y fin

void ImprimirN();
void Ingresar();

char nombre[20];
float sueldo,salario,sueldoneto;
int dias,i,j;

int main()
{
clrscr();
for(i=0;i<2;i++)
Ingresar();
for(j=0;j<2;j++)
ImprimirN();
getch();
}

void Ingresar()
{
cout<<"\nNombre: ";
gets(nombre); //Va a tomar todos los caracteres, incluyendo espacios
cout<<"\nSueldo: ";
cin>>sueldo;
cout<<"\nSalario: ";
cin>>salario;
cout<<"\nDias que trabajo: ";
cin>>dias;
cout<<"\nSueldo Neto: ";
cin>>sueldoneto;

//"c:\\trabajad.txt" es la ubicacion y nombre del archivo

//como se crea cuando se ejecuta el programa por primera
//vez, se le puede dar una ruta distinta y el nombre debe
//ser de maximo, ocho caracteres.
ofstream fout("c:\\trabajad.txt",ios::app); //Abre el archivo para escritura
//el ios:app, hace que cada nuevo dato se agrage al final del archivo
fout<<"\nRelacion de Trabajadores "; //Escribe en el archivo
fout<<"\nNombre: "<<nombre<<"\nSueldo: "<<sueldo<<"\nSalario: ";
fout<<salario<<"\nDias que trabajo: "<<dias<<"\nSueldo Neto:;
fout<<sueldoneto<<"\n---------------";
fout.close(); //Cierra el archivo
clrscr(); //Vuelve a limpiar la pantalla
}

void ImprimirN()
{
int num;
ifstream fin("c:\\trabajad.txt"); //Abre el archivo para lectura
char ch;
while(fin.get(ch)) //Mientras hayan datos, leelos
cout<<ch; //e imprimelos
ofstream fix("c:\\trabajad.txt"); //Escribe los datos en el archivo
fix<<ch; //para evitar su repeticion
fin.close(); //Cierra el archivo
}
Comportamiento de Ofstream

Pueden utilizarse ios para modificar el comportamiento del oftream.

· ios::app Agrega los datos al final del archivo

· ios::ate Pone el cursor al final del archivo pero te permite escribir
donde sea
· ios::trunc Trunca el archivo.
· ios::nocreate Si el archivo no existe, ocurre un error
· ios::noreplace Si el archivo ya esxite, ocurre un error
 Comentarios Finales

Espero que este tutorial les sea útil como una pequeña introducción al
lenguaje de programación C++. Obviamente, queda mucho camino por
recorrer, uno no puede abarcar todas las posibilidades que posee un
lenguaje, en un tutorial, ni en diez libros. Lo importante ahora, es que
busque otros tutoriales con los que pudean complementarse y bajen códigos
y lo revisen hasta comprenderlos a la perfección. Demás está decir que
cuentan conmigo para cualquier duda que tengan.

Pueden acceder a mi página web:

SinglePath games design

Escribirme un mail:
[email protected]

O ingresar a:
Xpertia (http://www.xpertia.com)
Nombre de experto: blag
y consultarme a mi o a los más de 65 expertos disponibles en el área de
"Programación".
 Bibliografía y Agradecimientos

Bibliografía:

· "Teach Yourself C++ in 21 Days" de Sams Publishing.

· http://www.planet-source-code.com
· http://lawebdelprogramador.com

Agradecimientos:

· Jesse Liberty de Liberty Associates, autor de "Teach Yourself C++ in

21 Days".
· www.Planet-Source-Code.com
· www.La web del programador.com
· www.xpertia.com
· www.informit.com
· Mi novia Milly, por todo su apoyo.
15.- El Fín