Curso de C++

Tabla de contenido
Capítulo I. Introducción. ................................................................................................................ 4

Programación en C++. ........................................................................................................................................4
Historia de C++ ...................................................................................................................................................4
Instalación y configuración de un entorno de desarrollo IDE) para C++ ............................................................6
Dev C++ ...........................................................................................................................................................7
Eclipse C++: .....................................................................................................................................................7
Visual C++ (Visual Studio): ..............................................................................................................................7
Netbeans C/C++: .............................................................................................................................................7
Code::Blocks: ..................................................................................................................................................8
Creación de un proyecto en el IDE Visual C++. Proyectos en C++ ......................................................................8
¿Cómo crear y ejecutar un proyecto en Visual C++ .......................................................................................9
Comentar código en C++. Documenta tus aplicaciones por medio de comentarios en tu código. .................10
Capítulo II. Estructura básica de un programa en C++. .................................................................. 12
Capítulo III. Sistema de tipos de datos en C++. Números, textos, booleanos, variables y constantes.
................................................................................................................................................... 16
Tipos de datos primitivos en C++. Declaración y asignación a variables..........................................................17
¿Cómo se declara una variable en C++? .......................................................................................................17
Tipos de Datos en C++ ......................................................................................................................................19
Instrucciones de Asignación .............................................................................................................................20
Variables y constantes en C++. Asignación de valores, uso de #define y const en C++ ...................................20
Constantes en C++, const y #define .............................................................................................................22
Uso de #define para declarar constantes en C++ .........................................................................................22
Uso de const para declarar constantes en C++ ............................................................................................24
¿Cuándo usar una variable o una constante en C++? ..................................................................................25
Capítulo IV. Entrada y salida de datos en C++. Uso de cin y cout ................................................... 26
Salida de texto por pantalla en C++..................................................................................................................27
Entrada o lectura de datos en C++ ...................................................................................................................28
Capítulo V. Los condicionales en C++. Uso declaración y sintaxis en C++ ....................................... 31
Condicional if en C++. Declaración, uso y sintaxis del if en C++ .......................................................................32
¿Cómo funciona un Condicional If? ..............................................................................................................32
Sintaxis del Condicional If en C++: ................................................................................................................33
1
Condicional if else en C++. Declaración uso y sintaxis del if else en C++ ........................................................ 36
¿Cómo funciona un Condicional If-Else? ..................................................................................................... 36
Sintaxis del Condicional If-Else en C++: ....................................................................................................... 36
Condicional switch en C++. Declaración uso y sintaxis de switch en C++ ....................................................... 40
¿Qué es Condicional Switch? ....................................................................................................................... 40
¿Cómo funciona el Switch? ......................................................................................................................... 41
Sintaxis del Condicional Switch en C++: ...................................................................................................... 41
Capítulo VI. Los bucles o ciclos en C++. Declaración, uso y sintaxis de un ciclo en C++ ................... 46
Ciclo for en C++. Estructura, sintaxis y uso de un ciclo for en C++ .................................................................. 47
¿Cómo funciona un Ciclo For? ..................................................................................................................... 47
Sintaxis del Ciclo For en C++: ....................................................................................................................... 48
Ejemplos de Ciclo For en C++....................................................................................................................... 49
Ciclo while en C++. Estructura y sintaxis. Cómo y para qué usar un ciclo while en C++ ................................. 54
¿Cómo funciona un Ciclo While? ................................................................................................................. 54
Sintaxis del Ciclo While en C++: ................................................................................................................... 54
Ciclo do-while en C++. Estructura y sintaxis. Cómo y para qué usar un ciclo do-while en C++ ...................... 58
¿Cómo funciona un Ciclo Do-While? ........................................................................................................... 58
Sintaxis del Ciclo Do-While en C++: ............................................................................................................. 59
Ciclos anidados en C++. Creando ciclos al interior de otros ciclos .................................................................. 62
¿Cómo funciona un ciclo anidado?.............................................................................................................. 63
Sintaxis de ciclos anidados: ......................................................................................................................... 63
Capítulo VII. Estructuras de datos en C++. Uso, manejo y ventajas. Arreglos, vectores, matrices y
demás. ........................................................................................................................................ 68
Arrays, arreglos o vectores en C++. Uso, declaración y sintaxis de los vectores en C++ ................................ 69
Ejemplo de Arrays o Vectores en C++ ......................................................................................................... 69
Posible Solución 1: Sin usar vectores (errónea): ......................................................................................... 69
Posible Solución 2: Sin usar vectores o matrices (errónea): ....................................................................... 70
Posible Solución 3: Usando vectores o matrices (correcta): ....................................................................... 70
¿Cómo declarar un Array o Vector en C++? ................................................................................................ 71
¿Cómo inicializar un Array o Vector en C++? .............................................................................................. 72
Particularidades de los Arrays, arreglos o Vectores en C++ ........................................................................ 73
Obtener el valor de una casilla específica en un array en C++ .................................................................... 75
Recorrer un Array o Vector en C++.............................................................................................................. 75
Matrices en C++. Uso, declaración, y sintaxis de las matrices en C++ ............................................................ 81
2
Matrices en C++ un buen ejemplo ...............................................................................................................82
¿Cómo se crea una Matriz en C++? ..............................................................................................................82
Declaración de una matriz en C++ ................................................................................................................83
¿Cómo inicializar una matriz en C++?...........................................................................................................84
Recorrer una matriz en C++ ..........................................................................................................................85
Los punteros y elementos dinámicos en C++ con ejemplos y ejercicios resueltos. .........................................88
Detalles al crear y usar punteros en C++ ......................................................................................................89
Los punteros y el ampersand .......................................................................................................................89
Los apuntadores y el asterisco .....................................................................................................................89
Array dinámico .............................................................................................................................................92
Matrices dinámicas.......................................................................................................................................94
Capítulo VIII. Bibliotecas o librerías en C++. Declaración y uso de librerías. Include en C++ ........... 97
¿Qué son exactamente las librerías?................................................................................................................97
Sintaxis para declarar Librerías en C++.............................................................................................................98
Librerías Estándar de C++ (Standar Template Library o STL) .......................................................................98
¿Cómo declarar una librería en C++? .............................................................................................................100
Acerca del namespace std ..............................................................................................................................101
Capítulo IX. Funciones, métodos y procedimientos en C++. Desde cero y paso a paso ................. 105
¿Funciones, métodos o procedimientos? ......................................................................................................105
Declarando funciones en C++ .....................................................................................................................106
Consejos acerca de return ..........................................................................................................................107
Hablemos un poco de los procedimientos .................................................................................................109
Invocando funciones y procedimientos en C++ .........................................................................................109
Detalles para invocar funciones .................................................................................................................110
3
Capítulo I. Introducción.
Programación en C++.
En este curso, no se pretende profundizar demasiado, pues la sección se alargaría infinitamente y
comenzaría a tratar temas demasiado avanzados y difíciles de entender, así que solo se hablara un
poco sobre la programación básica en C++, cosas como: ¿Cómo declarar una variable?, Tipos de
variables, funciones, un poco de punteros (aunque no mucho), librerías (las más comunes, pues
existen muchísimas) compiladores principales, algunas estructuras de datos, operadores y quizá
algunas cosas más.
Muy bien manos a la obra, veamos algunas cuantas cosas sobre C++ y de teoría que nunca debería
faltar, aunque sé que no es lo más entretenido, pero hagámoslo por cultura general, nunca se sabe
cuándo se va a necesitar algún conocimiento.
Historia de C++
C++ es algo así como la evolución del lenguaje C. La intención de su creación fue el extender al exitoso
lenguaje de programación C con mecanismos que permitan la manipulación de objetos. En ese
sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.
La historia de C (predecesor de C++) parte de un lenguaje anterior, el lenguaje B, escrito por Ken
Thompson en 1970 con el objetivo de recodificar el sistema operativo UNIX, que hasta el momento se
había programado en ensamblador. Lo malo del lenguaje ensamblador era que lo ligaba a una serie
de máquinas concretas, por lo que conseguir un lenguaje abstraído de cada máquina conseguiría una
portabilidad del sistema muchísimo mayor. A su vez B fue inspirado en el BCPL de Martin Richards,
diseñado tres años antes.
En 1972 es Dennis Ritchie (de los Laboratorios Bell de AT&T) quien diseña finalmente C a partir del B
de Thompson, aportando un diseño de tipos y estructuras de datos que consiguen una claridad y
eficacia en el lenguaje muy superior. Es un lenguaje que permite realizar una programación
estructurada economizando las expresiones, con abundancia de operadores y tipos de datos (aunque
los básicos sean pocos), codificando en alto y bajo nivel simultáneamente, reemplazando
4
ventajosamente la programación en ensamblador y permitiendo una utilización natural de las
funciones primitivas del sistema.
Durante muchos años no existieron reglas estándar para el lenguaje, pero en 1983 se decide formar
un comité con el objetivo de crear el estándar ANSI. El proceso dura seis años y a principios de los 90
el estándar es reconocido por la ISO (Organización Internacional de Estándares) y comienza a
comercializarse con el nombre ANSI C.
Nota: Lo que verás a continuación es un algoritmo escrito en C, lo cual es una pequeña aproximación
a lo que es C++ como tal, no te preocupes si no entiendes lo que dice o hace este código, pues más
adelante lo comprenderás a la perfección. Este código, escribe en pantalla la frase "Hola Mundo" (sin
las comillas).
/* "Hola mundo" escrito en C */

#include "stdio.h"
void main()
{
printf( "Hola mundo" );
}
Paralelamente, en 1980 surge C++ de la mano de Bjarne Stroustrup (también de Laboratorios Bell de
AT&T). Diseña este lenguaje con el objetivo de añadir a C nuevas características: clases y funciones
virtuales (de SIMULA 67), tipos genéricos y expresiones (de ADA), la posibilidad de declarar variables
en cualquier punto del programa (de ALGOL 68), y sobre todo, un auténtico motor de objetos con
herencia múltiple que permite combinar la programación imperativa de C con la programación
orientada a objetos. Estas nuevas características mantienen siempre la esencia del lenguaje C: otorgan
el control absoluto de la aplicación al programador, consiguiendo una velocidad muy superior a la
ofrecida por otros lenguajes. El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando
el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el
nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++
es una extensión de C. El siguiente hecho fundamental en la evolución de C++ es sin duda la
incorporación de la librería STL años más tarde, obra de Alexander Stepanov y Andrew Koening. Esta
5
librería de clases con contenedores y algoritmos genéricos proporciona a C++ una potencia única entre
los lenguajes de alto nivel.
Debido al éxito del lenguaje, en 1990 se reúnen las organizaciones ANSI e ISO para definir un estándar
que formalice el lenguaje. El proceso culmina en 1998 con la aprobación del ANSI C++.
Finalizaremos esta parte con el famoso "Hola Mundo" en C++, puedes comparar la diferencia entre
ambos códigos y determinar las nuevas características que tiene C++ sobre C.
// "Hola mundo" escrito en C++
// #include "iostream" esta opción también es correcta

#include <iostream>
using namespace std;
int main()
{
cout << "Hola mundo";

return 0;
Estuvo bueno ¿verdad? Bien, ahora eres todo un experto seguidor de C++, conoces su evolución,
creadores y demás detalles, pero aún no sabemos programar en él, sin embargo, ten paciencia, que a
eso vamos.
Instalación y configuración de un entorno de desarrollo IDE) para C++

En esta sección conoceremos algunos de los mejores y más populares entornos de desarrollo para
C/C++ (IDE). Conoceremos los principales IDE para C++ y sus principales características.
Primero que todo, como aclaración, es bueno decir que existen una enorme cantidad de entornos de
desarrollo para C y C++ conocidos también como IDE. Aquí solo mencionaré algunos de los quizá más
conocidos entornos de desarrollo y les diré cuál es el mejor IDE, claro, desde mi punto de vista, pues
habrá quienes prefieran otro, eso quedará al gusto de cada uno.
6
La lista de algunos de los principales entornos de desarrollo para C/C++ (IDE), en orden de utilidad
(nuevamente desde mi punto de vista).
Dev C++
Dev-C++ es un entorno de desarrollo integrado (IDE) para programar en lenguaje C/C++. Usa MinGW,
que es una versión de GCC (GNU Compiler Collection) como su compilador. Dev-C++ puede además
ser usado en combinación con Cygwin y cualquier compilador basado en GCC.
Eclipse C++:
El IDE Eclipse para desarrollo en C/C++ se ejecuta sobre la plataforma Eclipse. Esta proporciona
funcionalidades avanzadas como son: un editor (con resaltado de sintaxis y autocompletado de
código), un ejecutor de código, un depurador, motor de búsqueda. Este entorno de desarrollo también
es bastante completo y es una muy buena opción.
Visual C++ (Visual Studio):

Microsoft ha puesto a disposición del público una versión "gratuita" de uso personal de Visual C++,
éste es un completo entorno de desarrollo para C++, incluido en la suite de Visual Studio. Por supuesto,
está orientado a aplicaciones en Windows y es uno de los más populares por su facilidad de uso,
características y potencia. Posee una completa documentación que permite conocer a fondo el IDE.
Requiere por lo menos Windows 7 y debemos descargar el paquete completo para poder usarlo y
luego crear una cuenta para descargarlo.
Netbeans C/C++:
Netbeans en su versión para C/C++, es un entorno de desarrollo o IDE que nos permitirá desarrollar
aplicaciones nativas en C/C++ y fortran en una variedad de sistemas operativos (Windows, Linux, OS
X y Solaris). Podremos crear proyectos para C/C++ y hacer uso de plantillas pre diseñadas, para
aumentar nuestro rendimiento y velocidad de desarrollo, nos proporciona herramientas para depurar
nuestro código viendo el comportamiento y cambio de las variables y componentes de nuestra
7
aplicación. Nos proporcionas grandes ventajas como sugerencias de código, auto-completado de
líneas, entre muchas cosas más.
Code::Blocks:
Code::Blocks es un entorno de desarrollo (IDE) libre para C/C++ creado para suplir las más importantes
necesidades de los usuarios. Fue diseñado para ser altamente configurable y extensible. Code::Blocks
puede ser extendido con plugins, mejorando así su funcionalidad. De todas las posibilidades que
encontré, desde mi punto de vista el más amigable, y sencillo de instalar.
¡¡Ahora sí!!! ¡¡Por fin!! Llegó el momento de aprender a programar en C++; ya tenemos lo necesario.
Creación de un proyecto en el IDE Visual C++. Proyectos en C++

La mayor parte de los entornos de desarrollo integrados (IDEs) para C++ incluso para otros lenguajes
de programación, hacen uso de un concepto de proyecto. Un proyecto en un entorno de desarrollo
(IDE) cualquiera, es un "contenedor" global, donde podemos incluir o crear todos los archivos
necesarios que tengan relación con una aplicación de software que estemos desarrollando, clases,
interfaces, archivos de texto, imágenes, paquetes, entre otros.
Un proyecto es un concepto existente en los entornos de desarrollo (IDEs) que nos permite dar orden
y una clasificación a nuestro trabajo y a nuestros programas, pues sería bastante malo tener cinco
proyectos distintos que estemos desarrollando y tener los archivos mezclados en un mismo lugar de
nuestro computador. Los proyectos nos permiten mantener ordenado nuestro espacio de trabajo
permitiéndonos ser más ágiles y evitar errores.
Ahora que comprendemos a qué nos referimos cuando hablamos de proyectos, vamos a ver cómo
crear un proyecto en Visual C++. En esta sección mostraré, con imágenes incluidas, cómo crear un
proyecto en este entorno de desarrollo. Comencemos:
8
¿Cómo crear y ejecutar un proyecto en Visual C++
En la mayoría de los entornos de desarrollo el proceso es bastante similar, pero aquí explicaré los
detalles relevantes de esto, para que, al momento de crear un proyecto, tú mismo, comprendas qué
puedes cambiar cuándo y para qué.
Como primer paso, necesitamos abrir nuestro entorno de desarrollo, de modo que, según nuestro
sistema operativo, deberíamos seguir una ruta como la siguiente. Vamos a: Inicio » Todos los
Programas » Microsoft Visual Studio Express » Microsoft Visual C++.
Una vez haya iniciado correctamente nuestro entorno de desarrollo, podremos entonces proceder a
la creación del nuevo proyecto.
Para crear el proyecto, debemos seguir unos pasos bastante simples. En nuestra ventana principal en
la parte superior tenemos una serie de opciones, debemos dar clic en: Archivo » Nuevo » Proyecto...,
tal como muestra la imagen.
Hecho esto, se nos mostrará una nueva ventana donde podremos seleccionar el tipo de proyecto a
crear, tenemos varias opciones, sin embargo, de momento que estamos aprendiendo, lo más
conveniente es crear un proyecto vacío, también allí podremos ingresar todo acerca de nuestro
proyecto como: nombre, ubicación y nombre de la solución. Para este ejemplo, como nombre a
nuestro proyecto, le pondremos Curso Aprender A Programar. La ubicación la podemos cambiar
dando clic en examinar, sin embargo, es recomendable dejarla en la ubicación por defecto por
comodidad y facilidad. El nombre de la solución, se pone automáticamente como el del proyecto, de
modo que no habrá necesidad de cambiarlos nosotros mismos.
En cuanto hayamos rellenado correctamente los campos, podremos dar clic en aceptar. Hecho esto,
se nos mostrará una vez más la ventana principal de Visual C++, sin embargo, en esta ocasión
9
podremos apreciar una estructura de carpetas en la parte izquierda de la ventana, donde podremos
poner de forma ordenada cada archivo.
Hecho esto, podremos añadir archivos a nuestro proyecto, archivos de código fuente, archivos de
cabecera y demás. Vamos a ver como añadir un archivo de código fuente a nuestro proyecto, para
añadir un archivo de cabecera u otro, el proceso es el mismo.
En cuanto tengamos nuestro proyecto creado podremos crear nuestro primer programa. A modo de
prueba, vamos a ejecutar el típico Hola Mundo que vimos en la Introducción a C++ de este curso, de
modo que podemos copiar de aquí el código y pegarlo en nuestro elemento de código fuente.
/* "Hola mundo" escrito en C++ */

#include <iostream>
int main()
{
cout << "Hola mundo \n";
system(“PAUSE”);
return 0:
}
Una vez pegado el código, podremos ejecutar nuestro primer programa en C++ presionando F5. AL
ejecutarlo se nos mostrara una ventana negra que es del símbolo del sistema (DOS o CMD),
escribiendo Hola Mundo y una línea más abajo Press any key to continue. Para salir presionamos
cualquier tecla y nuestro programa finalizará su ejecución.
Comentar código en C++. Documenta tus aplicaciones por medio de comentarios en

tu código.
Los comentarios son una herramienta proporcionada por un lenguaje de programación que nos
ayudará a apoyar la documentación de los programas en C++ y a que sean fácilmente comprendidos
por otros. Los comentarios, son líneas de código, que no son tenidas en cuenta por el compilador en
10
el momento de ejecutar nuestra aplicación, por lo tanto, no están sujetas a restricciones de sintaxis ni
nada similar, el uso principal de las líneas de comentario, es dar un orden y hacer más entendible
nuestro código, especialmente en el caso de que deba en algún momento ser revisado o leído por
alguien diferente a nosotros. Por ejemplo, es muy común usar las líneas de comentarios, para dar una
breve explicación de cómo funciona cierta parte de un código, lo cual permite identificar todo con
mayor rapidez. Existen dos tipos de comentarios en el lenguaje:
Comentarios de Una Sola Línea: Pueden ser colocados en cualquier parte y comienzan por un doble
slash "//", al colocar el doble slash al comienzo de cualquier línea de código, todo lo que halla de ahí
en adelante en esa misma línea será tomado como comentario, ten en cuenta que el doble slash solo
convierte en comentario al texto que haya después de él y que pertenezca a su misma línea, las líneas
de abajo de este, no se verán afectadas.
Comentarios Multi-línea: Van cerrados entre "/*" y "*/". Estos comentarios son similares a los
anteriores, pero deben tener un comienzo y un fin, a diferencia del anterior, al poner los símbolos "/*"
todo el código que haya tanto en la misma línea, como en las líneas debajo de este, se convertirán en
comentarios, de manera que debemos cerrarlo en el punto donde dicho comentarios termina.
Veamos algunos ejemplos

Comentarios de una línea
int i=0; //Declaración de variable
Comentarios multi-línea
float b; /*Esta sentencia (float b;), se ejecutaría
int b; pero esta no porque es comentario*/
Esta sección ha sido un poco corta pero sustancial. Ahora ya sabes y dominas una buena técnica de
programación. Comentar código es una muy buena práctica para todos y facilitarnos la vida con
nuestras aplicaciones.
11
Capítulo II. Estructura básica de un programa en C++.
Me parece que la mejor forma de no perder el interés de esta sección aburriéndolos con muchos
conceptos y teorías, es mediante un ejemplo (a todos nos gusta la práctica). Veamos entonces nuestro
primer programa en C++, que, aunque no es muy extenso ni complicado ni tampoco hace gran cosa,
nos ayudará a establecer unas bases que resultarán muy útiles para los siguientes ejemplos que irán
apareciendo durante el resto del curso. No te preocupes si no comprendes nada al principio, pues me
encargaré de irte enseñando cada cosa y así estaremos mejor, si no entiendes algo o crees que me
faltó explicar alguna cosa, dímelo.
El programa que vamos a realizar simplemente le dará a una variable el valor del resultado de sumar
5 + 5, cabe resaltar que en pantalla no se muestra nada por lo que la ejecución del programa será
prácticamente instantánea.
Este es nuestro programa:
int main()
{
int numero;
numero = 5 + 5;
return 0;
}
Nuestro primer código, consta de 7 líneas, las cuales te explicaré, una por una a continuación:
Línea 1:
Nuestra primer línea contiene el llamado a la función main, la función main(), es la más importante de
todas la funciones (es la madre del programa jejeje), pues es esta la que nuestro compilador buscará
12
para iniciar la ejecución de nuestro código, si esta función falta, nuestro programa no podrá arrancar,
pues no sabrá desde donde hacerlo. La función main, como cualquier otra debe tener un tipo, es decir
debe tener indicado cual es el valor que esta va a retornar al final, los tipos de las funciones pueden
ser, enteros (int), decimales simples(float), decimales dobles(double), booleanos(bool), vacíos (void)
entre algunos más, la función main, puede ser cualquiera de estos, pero por acuerdo, se coloca
siempre como entera (int) y siempre retornara 0 (luego hablare de esto), en ocasiones, aunque no es
recomendable se usa como vacía (void) y así no es necesario retornar ningún valor, pero pronto verás
porqué esto no es recomendable.
Línea 2:
La línea 2 contiene una llave abriendo "{", en C++, se usan las llaves tanto para indicar el comienzo
como el final de cada función, sea cual sea, es decir sea la función main o cualquiera que tu hayas
inventado, debe comenzar con una llave abriendo y terminar con una cerrando (tiene sentido ¿no?).
Es por esto, que esta llave se encuentra ahí, indicando el inicio de nuestra función main.
Línea 3:
Esta línea, contiene la declaración de una variable llamada numero, presta especial atención a esta
línea, pues es muy sensible a errores al momento de codificar, esta línea contiene primero el tipo de
nuestra variable, en este caso es entera (int) pero podría ser alguna de las que mencione
anteriormente o cualquier otra, lógicamente valida. Esta línea es sensible, porque tanto en C como en
C++ los nombres de las variables son sensibles a las mayúsculas y a las minúsculas, es decir, para C o
C++ la variable numero y la variable Numero, son dos variables totalmente distintas o la variable
Numero y la variable NuMeRo, debes tener cuidado en no mezclar mayúsculas y minúsculas, así que
acostúmbrate a escribir normalmente en minúsculas. Otro detalle de esta tercera línea es el punto y
coma ";" en C y C++ el punto y coma indican el final de una sentencia (no una sentencia de muerte o
algo así, ¡no te distraigas!), una sentencia es una línea de código, en la cual se realiza algún tipo de
operación, asignación, comparación o declaración (fíjate! todas terminan en "cion") por ejemplo la
línea 3, 5 y 6, son líneas de sentencia. Así que cada que realices cualquier operación en una línea, esta
debe termina con punto y coma, de lo contrario tendrás errores en tu código. Ten en cuenta que la
13
línea 1, no es una sentencia, pues aunque allí se está aparentemente declarando a la función main, no
es así, pues el int que hay antes del main() nos indica el tipo de valor que debe retornar nuestra
función, mas no exactamente el tipo que es nuestra función, por esto no se usa el punto y coma en la
línea 1 (ojo! no estoy diciendo que cuando se declare una función no se use punto y coma, no te
enredes con esto, en la línea 1 simplemente se está implementando la función main, más adelante lo
comprenderás, confía en mi).
Línea 4:
La línea 4 no tiene nada especial, es simplemente un campo vacío, no genera ningún tipo de cambio
para el compilador, pero nos permite ordenar un poco nuestro código. Quizá si eres curioso intenta
eliminar todos los saltos de línea dejando todo el código en una sola línea y veras que pasa (nada malo
te lo aseguro), así confirmaras tú mismo lo que dije acerca de los espacios en blanco.
Intenta algo como lo siguiente y me dices que pasa jeje:
int main(){ int numero;numero = 5 + 5;return 0; }
Línea 5:
Esta línea contiene una operación, por lo tanto, es una línea de sentencia (mira que termina con punto
y coma), en esta línea, estamos dándole o, mejor dicho, asignándole un valor a la variable numero,
que ahora tendrá el valor de la operación matemática 5 + 5 es decir, la variable numero valdrá 10.
Ahora que hablo de asignación, quiero explicarte algo que en ocasiones suele confundir y es que en
C++ hay dos operadores similares pero no idénticos que son el igual "=" y el doble igual "==", en C++
el igual solo "=" se usa para asignación, es decir para darle a una variable el valor de otra o el valor de
una operación especifica como por ejemplo 5 + 5, mientras que el operador de doble igual "==" se usa
para comparación, es decir para comparar si el valor de una variable es igual a otro, por ejemplo:
escribir numero = 5 + 5; es válido, pero escribir numero == 5 + 5; nos genera un error de sintaxis, las
acciones que realiza cada operación son distintas, la primera, le asigna el valor que tenga el resultado
de 5 + 5 (osea 10 jeje) a la variable "numero" mientras que la segunda verifica si el valor de la variable
"numero" es igual o no a 10. Si no entiendes bien esto último, no te preocupes, más adelante lo
14
veremos con más detalle. Recuerda que recién estamos comenzando, así que no te preocupes si no
entiendes mucho, te aseguro que al finalizar este curso sabrás bien todo esto.
Línea 6:
La línea 6 es otra línea de sentencia, y esta nos indica por medio del return lo que la función debe
retornar, en este caso, nos está diciendo que la función main(), deberá retornar cero cada vez que
termine, en realidad la función main podría retornar cualquier cosa o incluso nada (void), podría
retornar cualquier tipo de variable o incluso la variable numero misma, pero se ha establecido por
acuerdo que siempre debería retornar 0, pues dado el caso en que retorne otro valor estando la
sentencia return 0; dentro de ella, esto implicaría que hay algún error en la ejecución del programa.
Aquí está la importancia de poner al main retornando un valor de tipo int.
Línea 7:
Finalmente, nuestra línea 7 contiene la llave cerrando, esto nos indica que es el fin de la función main
y por tanto el fin de la ejecución de nuestro programa (donde termina el main, termina todo), cada
que nuestro compilador llega a la llave de cierre de la función main, dará por concluido el proceso de
nuestra aplicación, por lo tanto, cualquier línea que esté por debajo de esta llave de cierre no será
ejecutada, a menos que se indique lo contrario dentro de la función main.
Bueno, estoy seguro de que, hasta este punto, ya te has familiarizado un poco con los tipos de datos
primitivos de C++ (int, bool, char, etc) por lo que deberías estar listo para llevar a cabo las secciones
siguientes en las cuales profundizaremos mucho más acerca de cada uno de estos tipos de datos
primitivos, otros (no tan primitivos jeje) y algunas cosas más. Recuerda que apenas estamos
comenzando con esto, así que con paciencia llegaremos a dominar bien este lenguaje.
15
Capítulo III. Sistema de tipos de datos en C++. Números, textos,
booleanos, variables y constantes.
La intención principal de esta sección es dar una introducción a lo que se refiere al sistema de tipos de
C++, las variables en C++. Hablaremos específicamente acerca de los tipos de datos o variables más
comunes, sus características generales, su utilidad, entre otras cosas. En la primera sección
hablaremos con detalle acerca de variables y tipos primitivos en C++ y en la segunda sección
hablaremos también con detalle acerca de constantes y modificador const y #define en C++, pero eso
será en cada sección, por lo que aquí, solo veremos conceptos generales y una introducción al sistema
de tipos de C++, así que comencemos.
Como podrás imaginar C++ posee una buena cantidad de tipos de datos, sin embargo, de una manera
más general, algunos de estos son más sencillos simples de usar que otros. Veamos:
Tipos nativos o primitivos de C++

Los tipos nativos de C++, son los tipos de datos "fáciles de usar" es decir, como veremos un poco más
adelante en la sección de tipos primitivos. Los tipos primitivos como su nombre lo da a entender, son
los tipos de datos más básicos y simples del sistema de tipos de C++ y por ello es bastante fácil usarlos.
Cabe mencionar que C++ es un lenguaje orientado a objetos y posee una cantidad enorme de librerías
o bibliotecas que podemos usar, estas librerías nos proporcionan una serie de tipos de datos
adicionales que son de enorme utilidad, sin embargo estos tipos ya no son tipos de datos primitivos
sino que son tipos complejos y por ende van a poseer una serie de campos y funcionalidades
adicionales que no posee un tipo primitivo pero no te preocupes por esto, en la parte de librerías o
bibliotecas de C++ se hablara un poco de cómo se usan éstas y los tipos que proporcionan. Luego en
la sección de objetos y clases se hablará con más detalle al respecto.
16
Muy bien, esto ha sido todo en esta sección, ya debes saber que en C++ existen tipos primitivos y tipos
de datos complejos que podemos usar por medio de librerías o bibliotecas que incluimos en nuestros
proyectos.
Tipos de datos primitivos en C++. Declaración y asignación a variables

Conceptualmente, desde el punto de vista de un programador, una variable es un dato cuyo valor
puede cambiar a lo largo de la ejecución de un programa.
En un nivel más lógico, una variable ocupa un espacio de memoria para contener sus valores durante
la ejecución de un programa. Cada variable debe pertenecer a un tipo determinado dando también el
tamaño del espacio de memoria ocupado por la variable, y el modo en que se manipulará esa
memoria.
De momento veremos los tipos fundamentales (básicos), que son: void, char, int, float y double; en
C++ se incluye también el tipo bool. También existen ciertos modificadores, que permiten ajustar
ligeramente ciertas propiedades de cada tipo; los modificadores pueden ser: short, long, signed y
unsigned, y pueden combinarse algunos de ellos.
¿Cómo se declara una variable en C++?

Veamos rápidamente cómo se declaran las variables junto con su tipo de dato en C++.
La sintaxis para una variable es la siguiente: [modificadores] [tipo de variable] [nombre de la variable]
[=] [valor];
En la declaración de una variable se debe colocar como mínimo el tipo de dato, el nombre y el punto
y coma al final de la línea, los modificadores son opcionales, es decir no es necesario ponerlos y
tampoco es obligatorio asignarle un valor a la variable de inmediato. Si no se pone ningún modificador,
el compilador tomará nuestra variable como signed, es decir podría ser positivo o negativo.
En el momento de asignar un nombre a una variable se deben seguir algunas normas:
17
1. El nombre de una variable nunca debe comenzar con un número.
2. No debes incluir algunos caracteres como símbolos matemáticos, guiones (el guión bajo"_" si es
permitido), comas, punto y coma, comillas, signos de interrogación o espacios en blanco.
3. Deben tener un máximo de 40 caracteres.
También, hay algunas palabras que son reservadas del lenguaje, es decir tus variables no podrán tener
estos nombres (no creo que tengas problemas con esto, especialmente si escribes en español). Las
palabras son las siguientes:
Algunos ejemplos de nombres correctos:

 FechaNacimiento
 variable12
 nombre_variable
 contador
 ACUMULADOR
Algunos ejemplos de nombres incorrectos:

 12variable
 float
 register
 variable nueva
 nueva-variable
18
Tipos de Datos en C++
bool: El tipo de dato bool, tiene un tamaño de 8 bits y un rango entre 0 y 1, en pocas palabras es cero
o es uno (falso o verdadero). Este tipo de dato, es comúnmente usado en condicionales o variables
que solo pueden tomar el valor de falso o verdadero. Las variables de tipo bool no suelen llevar
modificadores, pues son innecesarios, ya que su rango es solo 0 y 1.
int: El tipo de dato int, tiene un tamaño de 32 bits y un rango entre -2.147.483.648 y 2.147.483.647.
Este tipo de dato, es usado para números enteros (sin cifras decimales). A continuación, algunas
combinaciones con los modificadores:
 short int: Tiene un tamaño de 16 bits y un rango entre -32.768 y 32.767.
 unsigned short int: Tiene un tamaño de 16 bits y un rango entre 0 y 65535.
 unsigned int: Tiene un tamaño de 32 bits y un rango entre 0 y 4.294.967.295.
 long long int: Tiene un tamaño de 64 bits y un rango entre -9.223.372.775.808 y
9.223.375.775.807.
 unsigned long long int: Tiene un tamaño de 64 bits y un rango entre 0 y 2exp64.
float: El tipo de dato float tiene un tamaño de 32 bits, es usado comúnmente en números con 6 o
menos cifras decimales. Tiene un rango entre 1,17549*(e^-38) hasta 3,40282*(e^+38).
double: El tipo de dato double tiene un tamaño de 64 bits, es usado para números de menos de 15
cifras decimales. Tiene un rango entre 2,22507*(e^-308) hasta 1,79769*(e^308).
 long double: Tiene un tamaño de 96 bits y una precisión de 18 cifras decimales. Tiene un rango
entre 3,3621*(e^-4932) hasta 1,18973*(e^4932).
char: Las variables del tipo char, son digamos las variables problema del lenguaje C y C++, puesto que
tienen una gran cantidad de restricciones y complicaciones, bastante molestas. Las variables de tipo
char, en C y C++ son consideradas vectores y como quizá sabrás a los vectores se les debe declarar un
tamaño máximo, entre corchetes "[ ]" lo cual restringe un poco al no saber qué tamaño podría llegar
a tener una cadena de caracteres, y aunque hay formas de evadir esto, es bastante complicado. Es
recomendable usar las variables de tipo string para las cadenas de caracteres, incluidas en la librería.
19
string.h que son bastante fáciles de usar. La sintaxis para declarar un char es la siguiente: char
nombre_char[tamañoMax]; o simplemente char nombre = 'valor' notar que va entre comillas simples.
Instrucciones de Asignación
Una instrucción de asignación, como su nombre bien lo dice, es una línea de código, que le asigna a
una variable cualquiera un valor cualquiera, preferiblemente adecuado al tipo de dato o a las
necesidades de dicha asignación. Una asignación tiene la siguiente sintaxis: nombre_variable = valor,
con esto le estamos diciendo a nuestro programa que la variable llamada "nombre_variable", tendrá
ahora como nuevo valor a "valor". Así entonces, por ejemplo, al escribir contador = 0; estamos
diciendo que la variable contador tendrá como nuevo valor 0, es de tener en cuenta que, al realizar
una asignación, si la variable tenía algún otro valor antes de esto, dicho valor se perderá y cambiaría
por el nuevo que le hemos ordenado.
Las asignaciones no solo se realizan entre variables y valores constantes, también se realizan entre
variables, por ejemplo variable1 = variable2, de este modo, la "variable1", tendrá ahora el valor que
tiene en ese momento la "variable2", es recomendable realizar estas asignaciones entre variables del
mismo tipo, es decir entre una variable de tipo entero y otra de tipo entero, aunque está permitido
hacer asignaciones entre variables de diferente tipo (numérico), esto genera una advertencia porque
puede causar perdida en la precisión de los datos, por ejemplo al pasar de float a int.
Variables y constantes en C++. Asignación de valores, uso de #define y const en C++

Las variables son altamente imprescindibles al momento de programar, de hecho, sería imposible
conseguir una aplicación con una funcionalidad básica sin usar variables; por esta misma razón es
necesario aprender a usarlas bien y lo tenemos muy fácil, pues su uso es bastante sencillo e intuitivo,
tanto para declararlas como para asignarles valores.
Las variables son posiciones en memoria donde estarán guardados los diferentes valores que le damos
o que toman durante la ejecución de los datos que usamos y normalmente estarán disponibles a lo
20
largo de la ejecución de nuestro programa. Para asignar valores a una variable en una gran variedad
de lenguajes que incluye a C++ se usa el operador "=" seguido del valor que le daremos a la variable
(no todos usan el "=" para esto). Veamos un ejemplo completo con todos los posibles usos que le
damos a una variable.
#include <iostream>
int main()
{
char x = 'a'; // Declaramos y asignamos en la misma línea
int num; //Declaramos el entero en una línea

num = 5; //Le asignamos un valor en otra línea
int num2 = 8; //Asignacion y declaracion al tiempo
float numero; //Un numero decimal

numero = 3.5; //Le asignamos un valor al decimal
float res = numero + num2; //Sumamos dos variables y las asignamos a res
//3.5 + 8 = 11.5
res = res + num; //Al valor actual de res le sumamos el valor de num
//11.5 + 5 = 16.5
bool valor = false; //Variable booleana

valor = true; // Pueden ser true o false
res = res*2; //Duplicamos el valor de res 16.5*2 = 33
cout << res << endl; //Mostramos el valor de res por pantalla
return 0;
}
En el código anterior hemos visto las múltiples formas en que se puede declarar una variable, cómo
asignarle un valor, incluso vimos que es posible asignarle el valor de una variable a otra, o realizar
operaciones entre los valores de variables y asignar el resultado a una variable nueva, vimos que es
posible usar el valor de una misma variable y cambiar su propio valor (res = res*2).
Ahora hablemos de las constantes en C++.
21
Constantes en C++, const y #define
Los datos constantes, mal llamadas por algunos "variables constantes" (realmente no son variables)
tienen un valor fijo durante toda la ejecución del programa, es decir, este valor no cambia ni puede
ser cambiado a lo largo de la ejecución de nuestro programa. Las constantes son muy útiles para
especificar el tamaño de un vector y para algunas otras cosas, como facilidad de uso y confiabilidad
del código. Para declarar una constante, se hace después de declarar las librerías y antes de las
funciones, la sintaxis es la siguiente: #define nombre_constante valor. Veamos algunos detalles y
luego unos ejemplos sencillos del uso de las constantes en C++
En C++ se pueden definir constantes de dos formas, ambas válidas para nosotros. La primera es por
medio del comando #define nombre_constante valor y la segunda es usando la palabra clave const,
veamos ahora cada una de estas formas en detalle.
Uso de #define para declarar constantes en C++

La instrucción #define nos permite declarar constantes (y algunas cosas más) de una manera rápida y
sencilla. Hay que tener en cuenta que al declarar constantes con #define debemos hacerlo después de
los #include para importar librerías, pero antes de declarar nuestras funciones y demás. Veamos un
ejemplo:
Ejemplo de uso de #define en C++ para declarar constantes
22
#include <iostream>
#define PI 3.1416; //Definimos una constante llamada PI
int main()
{
cout << "Mostrando el valor de PI: " << PI;
return 0;
}
Notemos que ha sido bastante fácil, sin embargo, no todo es bueno. Realmente al usar la instrucción
#define en C++ no estamos creando una constante realmente, estamos creando una expresión y por
tal motivo hay algunas cosas que se complican, veamos:
#include <iostream>
#define PI 3.1416; //Definimos una constante llamada PI
int main()
{
cout << "Mostrando el valor de PI: " << PI << endl;
return 0;
}
Si intentamos ejecutar el código anterior obtendremos un error al haber usado el operador << justo
después de PI, esto sucede porque PI no es tratado exactamente como una variable cualquiera sino
como una expresión, así que realmente, aunque podemos usar #define para declarar constantes no
es la mejor opción.
Veamos ahora cual es realmente la forma más adecuada de declarar constantes en C++, esto se hace
por medio de la instrucción const, veamos:
23
Uso de const para declarar constantes en C++
La instrucción const nos permite declarar constantes de una manera más adecuada y acorde. Las
constantes declaradas con const poseen un tipo de dato asociado (como debería ser siempre) y se
declaran al interior de nuestro código como un tipo cualquiera. Veamos un ejemplo:
Ejemplo de uso de const en C++ para declarar constantes
#include <iostream>
int main()
{
const float PI = 3.1416; //Definimos una constante llamada PI
return 0;
}
Notemos que de igual forma ha sido bastante fácil y mejor aún ha sido mucho más intuitivo y sencillo
para nosotros. Se puede ver que la declaración es muy similar a la de una variable cualquiera y que ya
no tenemos complicaciones al intentar añadir la instrucción endl para agregar el salto de línea. Veamos
que realmente la variable no puede cambiar:
24
#include <iostream>
int main()
const float PI = 3.1416; //Definimos una constante llamada PI
PI = 2; //Esto generará un error pues PI es de solo lectura (constante)
return 0;
Si intentamos ejecutar el código anterior obtendremos un error al intentar cambiarle el valor a PI, pues
lo hemos definido como una constante y el lenguaje no nos permitirá cambiarle en ningún momento
el valor.
¿Cuándo usar una variable o una constante en C++?

En general, la definición de variable y constante nos da una muy buena idea de cuándo usar una u
otra. Básicamente, si un valor puede cambiar en cualquier momento (aunque la probabilidad de que
eso suceda sea baja) entonces deberá ser una variable, en lugar de una constante.
Un ejemplo para soportar lo anterior sería el nombre del usuario. Podríamos pensar que un nombre
no va a cambiar, y es probable que no lo haga. Sin embargo, nada nos asegura que así sea, pues,
aunque es improbable es posible. Adicionalmente, nuestro programa puede cambiar de usuario y por
ende su nombre podría variar mientras el programa se ejecuta. Por lo tanto, NO debería ser una
constante.
25
Por otro lado, hay valores que no van a cambiar a lo largo del tiempo. Por ejemplo, la velocidad de la
luz se ha acordado siempre como la misma, así que debería ser una constante para evitar que sea
cambiada de cualquier modo durante la ejecución del programa. Valores como el número PI, el código
de estado de una página no existente (404), son valores que son convenciones existentes y que NO
deberían cambiar, por lo cual se los declara como constantes.
Finalmente, el uso de constantes en C++ (y en cualquier otro lenguaje de programación) ayuda mucho
a mejorar la comprensión del código que escribimos pues no es lo mismo que nuestro código ponga:
if (velocidad == 299792458)
A que diga
if (velocidad == VELOCIDAD_LUZ)
Pues en el segundo caso, queda muy claro que estamos comparando la variable velocidad con la de la
luz que es una constante. Por supuesto, anteriormente tendríamos que haber declarado la constante
VELOCIDAD_LUZ con su respectivo valor (tal como se explicó anteriormente).
Muy bien eso ha sido todo en esta sección, espero haber sido lo más claro posible y que se haya
entendido a la perfección.
Capítulo IV. Entrada y salida de datos en C++. Uso de cin y cout

La entrada y salida de datos en C++ es simple (al menos para los casos más comunes). Con esto hago
una comparación entre C++ y Java, pues leer una entrada del usuario por teclado en C++ es bastante
simple mientras que en Java implica una serie de conceptos adicionales que la hacen un tanto más
complicada. Por suerte para nosotros en esta sección veremos cómo leer por teclado en C++, en otras
palabras, asignar a una variable el valor que el usuario escriba por el teclado. Adicional a esto veremos
también cómo mostrar texto por pantalla en C++, es decir, salida de datos.
Vamos a comenzar primero con aprender a mostrar texto por pantalla en C++. Esta orden se debe a
que cuando queremos pedirle algún dato al usuario primero debemos hacerle saber lo que queremos
26
que ingrese y para hacérselo saber debemos mostrarle un mensaje con las indicaciones, por tal motivo
es importante primero saber mostrar texto en pantalla en C++ y luego a leer texto por teclado en C++.
Salida de texto por pantalla en C++

Mostrar texto por pantalla en C++ es muy simple. Para imprimir una salida de texto en C++ se hace
uso de la instrucción cout<< es importante tener en cuenta que la instrucción cout siempre va
acompañada de << para controlar el flujo de datos que sale. No te fijes mucho en ellos, solo ten
siempre presente que cout viene acompañado de << para tener cout<< como resultado.
Veamos algunos ejemplos para mostrar texto por pantalla en C++:

Ejemplo 1 de impresión de texto por pantalla en C++
#include <iostream>
int main()
{
//Se muestra un mensaje por pantalla.
cout << "Hola Mundo" << " Desde AAP." << endl;
return 0;
}
El ejemplo que acabas de ver es
bastante sencillo, excepto por un detalle. Si al ejecutar este código en tu pantalla aparecerá un
mensaje diciendo "Hola Mundo Desde AAP.". Tal como habrás notado el operador << se usa para
concatenar (unir) dos cadenas de texto por eso el resultado es el obtenido. Luego se usa endl indicando
el final de la línea lo cual crea un salto de línea. No es obligatorio, pero es recomendable.
Ejemplo 2 de impresión de texto por pantalla en C++.
27
#include <iostream>
#include <string>
int main()
{
string salida1 = "Ejemplo de salida"; //El valor de esta variable se mostrará en pantalla
int numero = 2; //Este valor también se mostrará en pantalla.
string salida2 = "Desde AAP."; //Estos valores se concatenarán en una única salida
//Se concatenan y muestran los valores por pantalla con cout<<

cout << salida1 << " " << numero << ". " << salida2 << endl;
return 0;
}
En este ejemplo de salida por pantalla hemos visto que también es posible usar la instrucción cout
para mostrar en pantalla el valor de las variables así sean numéricas o cadenas de texto. También
vimos que podemos concatenar los valores de esas variables entre sí y también concatenarlas con
otros valores directamente (espacios, puntos, símbolos, etc.).
Ya tenemos claro cómo mostrar texto por pantalla en C++ ahora haremos uso de este concepto y
veremos cómo leer texto por teclado en C++. Veamos:
Entrada o lectura de datos en C++

Tal como mencioné hace un momento, la lectura de datos en C++ es bastante simple. Leer datos por
teclado en C++ se hace usando el comando cin >> es importante notar el uso de los dos signos >> que
son usados para controlar el flujo de datos. No te preocupes mucho por ellos, solo ten en cuenta que
cada vez que vayas a usar la instrucción cin debes agregarle >> para quedar con un cin>>. Una manera
muy sencilla de recordar esta instrucción es que in significa entrar y como estamos programando en
C++ le añadimos la letra C al comienzo quedando así cin>> (sin olvidar los >>).
28
Veamos unos ejemplos simples para leer datos en C++. Recuerda como dije más arriba que lo ideal
para leer datos es indicarle al usuario qué es lo que esperamos que ingrese por lo que en estos
ejemplos usaremos también lo recién aprendido (mostrar texto por pantalla).
Ejemplo 1 de lectura de datos en C++
#include "iostream"
#include "string"
int main()
{
cout << "Hola! Este es un ejemplo en C++" << "\n" << "Por favor ingrese su nombre:" << endl;
//La instrucción \n es un salto de línea Mostrando los textos separados
string nombre;//En esta variable estará almacenado el nombre ingresado.

cin >> nombre; //Se lee el nombre
cout << "Bienvenido al sistema " << nombre << ". Gracias por usar nuestra aplicación" << endl;
return 0;
}
En este ejemplo hemos hecho un pequeño sistema de bienvenida personalizado para el usuario
leyendo el valor por teclado de su nombre. En el comando cin>> se debe poner, después de >>, el
nombre de la variable en la cual se almacenará el valor que el usuario ingrese. Por tal motivo primero
se declaró primero una variable llamada nombre y luego se usó cin >> nombre indicando que lo que
el usuario ingrese se almacenará en dicha variable.
29
Ejemplo 2 de lectura de datos en C++
#include "iostream"
#include "string"
int main()
{
cout << "Hola! Aqui podras realizar sumas" << endl; //Mensaje de bienvenida
float numero1, numero2; //Se declaran los números que se sumarán (pueden ser decimales)
cout << "Por favor ingrese el primer valor: " << endl; //Se pide el primer numero
cin >> numero1; //Se asigna el primer valor a numero1
cout << "Por favor ingrese el segundo valor: " << endl; //Se pide el segundo numero
cin >> numero2; //Se asigna el segundo valor a numero2
cout << "El resultado de la suma de " << numero1 << " + " << numero2 << " es: " <<
numero1+numero2 << endl; //Se muestra el resultado.
return 0;
}
Muy bien eso ha sido todo en este contenido. Espero que te haya sido de muchísima utilidad. Si has
comprendido todo a la perfección y no tienes problemas ni dudas, puedes continuar.
30
Capítulo V. Los condicionales en C++. Uso declaración y sintaxis
en C++
Los condicionales en C++, son una estructura de control esencial al momento de programar y aprender
a programar. Tanto C como C++ y la mayoría de los lenguajes de programación utilizados actualmente,
nos permiten hacer uso de estas estructuras para definir ciertas acciones condicionales específicas en
nuestro algoritmo. Un condicional, permite establecer una serie de condiciones al interior de nuestro
programa, que nos ayudan a determinar qué acciones llevará cabo dadas ciertas circunstancias, por
ejemplo si queremos decidir cuándo dar acceso a un usuario, dependiendo de si el nombre de usuario
y contraseña son correctos, para algo como esto, es útil un condicional, nos permite verificar si
determinada condición se cumple (en este caso si la contraseña y el nombre de usuario son correctos)
y de acuerdo a que se cumpla o no, llevar a cabo un conjunto de acciones. Los condicionales aumentan
la "expresividad" de un software, es decir nos permiten considerar diferentes situaciones con
antelación, evitando o permitiendo sortear diferentes tipos de situaciones que son del interés de
nuestra aplicación.
Existen diferentes tipos de condicionales, cada uno tiene una utilidad y funcionalidad diferente, que
consideran diferentes situaciones que se pueden llegar a presentar durante la ejecución de un
algoritmo. Depende entonces del conocimiento que tengamos acerca de cada uno de los condicionales
saber determinar correctamente cuando es necesario implementar uno u otro. Tenemos a nuestra
disposición los siguientes tipos de condicionales en C++:
 Condicional If en C++
 Condicional if-else en C++
 Condicional Switch en C++
Como se mencionó anteriormente, cada uno de estos condicionales tiene ciertas características que
lo hacen útil para algunos casos específicos, a lo largo de los contenidos de esta sección veremos cada
uno de estos al detalle, aprendiendo durante el proceso los componentes de un condicional, sintaxis
de los condicionales y esas características particulares que permiten decidir cuál usar en qué
momento, veremos también el concepto de condicionales anidados, y algunas otras cosas.
31
Te recuerdo que, aunque se intentara profundizar bastante en cada concepto, se hará enfocándome
hacia el uso de los condicionales en el lenguaje C++ y no tanto hacia la parte de la lógica de estas
estructuras condicionales en particular, si tienes problemas con la correcta comprensión de la lógica
y utilidad de cualquier tipo de condicional o de los condicionales en general.
Muy bien, ahora que sabemos un poco acerca de las estructuras de control condicionales (o
simplemente condicionales jeje) y que además sabemos que existen varios tipos de estos, podemos
comenzar a aprender y dominar cada uno de estos tipos de condicionales en C++.
Condicional if en C++. Declaración, uso y sintaxis del if en C++

Los condicionales if, son una estructura de control condicional, que nos permiten tomar cierta decisión
al interior de nuestro algoritmo, es decir, nos permiten determinar qué acciones tomar dada una
condición, por ejemplo, determinar si un numero cualquiera es mayor que 10 y de acuerdo a esto
mostrar un mensaje.
En resumen, un condicional if es una estructura que nos posibilita definir las acciones a ejecutar si se
cumple cierta condición.
¿Cómo funciona un Condicional If?

Para comprender mejor cómo funciona el condicional if, una muy buena forma es partiendo de un
ejemplo. Supongamos que queremos verificar si el resultado de una suma ingresada por el usuario es
correcto o no. Para este ejemplo, el condicional if, es el encargado de verificar si el resultado ingresado
corresponde o no a la respuesta correcta de la suma. El condicional if, funciona verificando la condición
ingresada y de acuerdo a su valor de verdad (falso o verdadero) lleva a cabo o no una serie de
instrucciones.
Espero haber sido claro, sino, no te preocupes, pues veremos ya mismo algunos ejemplos para
entender todo mejor.
32
Sintaxis del Condicional If en C++:
La sintaxis de un condicional if, es bastante simple e incluso creo que intuitiva. Vamos entonces a ver
rápidamente como es la estructura para ir luego a unos ejemplos y quedar bien claros. Veamos:
if(condición a evaluar) //Por ejemplo X <= 10

{
....
....
Bloque de Instrucciones si se cumple la condición....
....
....
}
....
Bloque de Instrucciones restante DEL ALGORITMO....
....
Vamos ahora a ver línea por línea el anterior código para comprender todo y quedar claros.
Posteriormente veremos un ejemplo con valores reales.
Línea 1:
En esta línea está prácticamente todo lo esencial del condicional, aquí le hemos dicho al interior del
argumento del condicional if, cual es la condición que se debe cumplir para que se ejecute el primer
bloque de instrucciones, esta línea es en efecto esencial ya que nos da la pauta para que el algoritmo
determine si ejecutará o no el bloque de instrucciones al interior de las llaves.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como seguramente ya sabrás indica que allí
comienza el bloque de instrucciones que se ejecutarán si se cumple la condición dada. Esta llave no es
del todo obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo la primera
línea inmediatamente posterior a la declaración del condicional, de modo que, si deseamos que se
ejecuten varias líneas dentro de nuestro condicional, debemos usar las llaves.
33
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo en caso de
cumplirse la condición, este bloque podrá tener la cantidad de líneas necesarias incluso, como
veremos más adelante dentro de estas podría haber uno o más condicionales en su interior, así que
podrías tener lo que se conoce como condicionales anidados (ya veremos eso más adelante).
Línea 8:
En esta línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya sabrás esta nos
indica que allí termina el bloque del condicional y se dará por terminada la ejecución de este para
continuar ejecutando el resto del programa.
Línea 9 a 11
Estas líneas contienen la estructura restante del algoritmo, quise ponerlas allí, para que quede claro
que sin importar si la condición se cumple o no, el algoritmo siempre va a ejecutar estas líneas, es
decir las líneas que se encuentran después de la llave de cierre de un condicional, siempre se
ejecutarán sin importar si la condición se cumpla o no.
No te preocupes si no comprendiste muy bien lo que acabo de escribir, estoy seguro que con un par
de ejemplos que veremos a continuación, te va a quedar todo claro.
Ejemplos de Condicional If-else en C++

A continuación, vamos a ver unos cuantos ejemplos para comprender de manera adecuada el uso de
los condicionales if en c++, recuerda que, si no comprendes alguno de estos ejemplos o tienes alguna
pregunta o sugerencia sobre estos o cualquier contenido de la sección, puedes preguntar.
Ejemplo 1: Verificación de valores en C++

Vamos a retomar el ejemplo anterior, deseábamos un sistema, en el cual un usuario nos ingresaba el
resultado de una suma mostrada en pantalla y verificábamos si el resultado ingresado era el correcto
a esta operación. En caso de ser correcto, el sistema muestra un mensaje de felicitación.
34
Solución Ejemplo 1:
Debemos entonces determinar cuál va a ser nuestra condición a evaluar, en este ejemplo, la condición
debe ser que la respuesta ingresada, sea igual al resultado de la suma, veamos entonces como realizar
esto:
int resultado = 0;
cout << "Cuanto es 39+50? ";
cin >> resultado;
if(resultado == 39+50)
{
cout << "Respuesta Correcta. Felicitaciones!\n";
}
El código funcional completo sería el siguiente:
#include "iostream"
int main()
{
int resultado = 0;
cout << "Cuanto es 39+50? ";
cin >> resultado;
if(resultado == 39+50)
{
cout << "Respuesta Correcta. Felicitaciones!\n";
}
return 0;
}
Si no comprendes alguna de las líneas de estos códigos, te recomiendo leer los contenidos anteriores
(Entrada y Salida de Datos, Librerías ó Comentarios, Estructura de un Programa).
Efectivamente, los condicionales son extremadamente útiles pues permiten definirle a nuestro
software múltiples vías de ejecución contemplando así todas las posibilidades durante la ejecución.
Espero que todo te haya quedado claro en esta sección.
35
Condicional if else en C++. Declaración uso y sintaxis del if else en C++
Los condicionales if-else, son una estructura de control, que nos permiten tomar cierta decisión al
interior de nuestro algoritmo, es decir, nos permiten determinar qué acciones tomar dada o no cierta
condición, por ejemplo, determinar si la contraseña ingresada por el usuario es válida o no y de
acuerdo a esto darle acceso al sistema o mostrar un mensaje de error.
En resumen, un condicional if-else es una estructura que nos posibilita definir las acciones que se
deben llevar a cabo si se cumple cierta condición y también determinar las acciones que se deben
ejecutar en caso de que no se cumpla.
¿Cómo funciona un Condicional If-Else?

Para comprender mejor cómo funciona el condicional if-else, una muy buena forma es partiendo de
un ejemplo. Imaginemos que, en nuestro programa, deseamos implementar un sistema de logeo de
usuario, comprobando si la información suministrada coincide con unos los valores correctos y en este
caso mostrar un mensaje de bienvenida, y en caso de que no, se mostrará un mensaje de error. Como
podemos imaginar, es entonces necesario hacer que nuestro algoritmo, tome una decisión, de
acuerdo a los valores ingresados por el usuario, y definir los dos casos posibles en caso de fallo o en
caso de que no. Es para esto que sirve el condicional if-else, nos permite definir una condición que se
debe cumplir y de acuerdo a su cumplimiento o no tomar una acción correspondiente. Espero haber
sido claro, sino, no te preocupes, pues veremos ya mismo algunos ejemplos para entender todo mejor.
Sintaxis del Condicional If-Else en C++:

La sintaxis de un condicional if-else, es en principio similar a la del condicional if, pero adicionando una
nueva "estructura" que es el else, el cual indica la acción o conjunto de acciones a llevar a cabo, en
caso de que la condición del if no se cumpla. Cabe resaltar que el else siempre se pone
inmediatamente después del if, en caso de ser necesario, el else es incapaz de funcionar por sí solo,
siempre debe ir acompañado por un if. Veamos entonces como es la sintaxis de este:
36
if(condición a evaluar) //Por ejemplo 50 <= 10
{
....
....
Bloque de Instrucciones si se cumple la condición....
....
....
}
else
{
....
....
Bloque de Instrucciones si NO se cumple la condición....
....
....
}
Línea 1:
En esta línea está prácticamente todo lo esencial del condicional, aquí le hemos dicho al interior del
argumento del condicional if, cual es la condición que se debe cumplir para que se ejecute el primer
bloque de instrucciones, esta línea es en efecto esencial ya que nos da la pauta para que el algoritmo
determine que bloque de instrucciones ejecutar.
Línea 2:
comienza el bloque de instrucciones que se ejecutarán si se cumple la condición dada. Esta llave no es
del todo obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro condicional la
primera línea inmediatamente posterior a la declaración del condicional, de modo que, si deseamos
que se ejecuten varias líneas dentro de nuestro condicional, debemos usar las llaves.
37
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo en caso de
cumplirse la condición, este bloque podrá tener la cantidad de líneas necesarias incluso, como
veremos más adelante dentro de estas podría haber uno o más condicionales en su interior, así que
podrías tener todo un condicional dentro de un condicional dentro de otro condiconal... y así
sucesivamente jejeje.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya sabrás
esta nos indica que allí termina el bloque del condicional y se dará por terminada la ejecución de este
para continuar ejecutando el resto del programa, cabe notar que esta línea dará paso a la ejecución
del bloque de instrucciones del else, en caso de que la condición dada no se haya cumplido.
Línea 9 a 16
Estas líneas contienen la estructura else, que es la que indica que existe un bloque de instrucciones
que se debe ejecutar en caso de que la condición dada no se cumpla. Este bloque al igual que el del
condicional if, se abre y se cierra con llaves, recuerda que estas pueden ser opcionales, sin embargo,
siempre recomiendo usarlas como una buena práctica de programación.
Ejemplos de Condicional If-else en C++

los condicionales if-else en c++, recuerda que, si no comprendes alguno de estos ejemplos o tienes
alguna pregunta o sugerencia sobre estos o cualquier contenido de la sección, puedes hacer
comentarios.
38
Ejemplo 1: Sistema de logeo en C++
Vamos a retomar el ejemplo anterior, deseamos implementar un sistema de logeo de usuario, es decir,
queremos que el usuario nos ingrese una contraseña y deseamos comprobar si coincide con el valor
pre establecido. En caso de que los datos sean correctos se mostrará un mensaje de bienvenida, y en
caso de que no, se mostrara un mensaje de error y finalizará el programa.
Debemos entonces determinar cuál va a ser nuestra condición a evaluar, en este ejemplo, la condición
debe ser que la contraseña, sea idéntica a la establecida en nuestro sistema, veamos entonces como
realizar esto:
string password = "";

cout << "Ingrese la contrasenia: ";
cin >> password;
if(password == "myClave")
{
cout << "Contraseña correcta. Bienvenido";
}
else
{
cout << "Contraseña incorrecta.";
}
39
#include "iostream"
#include "string"
#include "stdlib.h"
int main()
{
string password = "";
cout << "Ingrese la contraseña: " <<endl;
cin >> password;
if(password == "myClave")
{
cout << "Contrasenña correcta. Bienvenido" <<endl;
}
else
{
cout << "Contraseña incorrecta." <<endl;
}
system("PAUSE");
return 0;
}
Efectivamente, los condicionales son extremadamente útiles pues permiten definirle a nuestro
software múltiples vías de ejecución contemplando así todas las posibilidades durante la ejecución.
Espero que todo te haya quedado claro en esta sección.
Condicional switch en C++. Declaración uso y sintaxis de switch en C++

¿Qué es Condicional Switch?
Los condicionales Switch, son una estructura de control condicional, que permite definir múltiples
casos que puede llegar a cumplir una variable cualquiera, y qué acción tomar en cualquiera de estas
situaciones, incluso es posible determinar qué acción llevar a cabo en caso de no cumplir ninguna de
las condiciones dadas.
40
¿Cómo funciona el Switch?
La mejor forma de entender el funcionamiento de algo, es viendo un ejemplo de esto, de este modo,
me parece que para comprender de forma adecuada como funciona un condicional Switch, es bueno
hacerlo poniendo un ejemplo. Imaginemos entonces que nuestro programa consta de un menú de
opciones digamos 3 opciones, cada una representada con un número correspondiente, es decir la
opción uno corresponde al número 1, la dos al 2 y así sucesivamente, queremos entonces que de
acuerdo a un número ingresado por el usuario ejecutemos una acción correspondiente y en caso de
que no corresponda a ninguna de las posibles opciones, mostrar un mensaje de error cualquiera. De
este modo, podemos identificar 3 casos distintos para nuestro switch o en otras palabras, hemos
identificado tres condiciones posibles que puede llegar a cumplir nuestra variable: el caso uno
corresponde a que el valor ingresado por el usuario sea el 1, es decir ejecutar la opción 1, el caso 2 el
número 2, etc. adicionalmente hemos encontrado la opción que se ejecutará por defecto en caso de
no suceder ninguno de estos casos, es decir si el usuario ingresa por ejemplo 10, mostraremos un
mensaje de error cualquiera.
Sintaxis del Condicional Switch en C++:

La sintaxis de una condicional Switch es bastante distinta a la de una condicional típica, sin embargo,
es bastante intuitiva y fácil de comprender, es solo cuestión de acostumbrarse. Veamos a continuación
la estructura general de un condicional Switch y luego unos cuantos ejemplos.
switch(opción) //donde opción es la variable a comparar

{
case valor1: //Bloque de instrucciones 1;
break;
break;
break;
//Nótese que valor 1 2 y 3 son los valores que puede tomar la opción
//la instrucción break es necesaria, para no ejecutar todos los casos.
default: //Bloque de instrucciones por defecto;
//default, es el bloque que se ejecuta en caso de que no se dé ningún caso
}
41
Línea 1:
Aquí, tenemos la declaración del condicional switch, estamos diciendo que lo que viene a continuación
es esto, entre los paréntesis, el switch recibe la variable que vamos a usar para comparar en cada uno
de los casos.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como hemos visto en secciones anteriores, indica
que allí comienzan los bloques de instrucciones que se ejecutarán para cada caso.
Línea 3:
En esta línea tenemos una parte vital del condicional switch, aquí tenemos definido un caso posible
que puede cumplir nuestra variable, la sintaxis es simple, usamos la instrucción "case" para indicar
que allí comienza un caso, luego indicamos el valor que puede tomar la variable, puede ser un número,
una cadena de caracteres o lo que necesitemos, de esto se siguen dos puntos ":" y después de estos
ponemos la o las instrucciones a ejecutar para este caso, como ejemplo, podríamos tener algo como
esto : case "Hola": cout << "Usted ha escrito Hola";.
Línea 4:
Esta línea contiene la instrucción break, es una instrucción simple, pero fundamental al interior del
condicional Switch, esta instrucción indica que hasta allí va el bloque de instrucciones del caso
inmediatamente anterior a este, de este modo evitamos que el algoritmo ejecute los demás casos, a
modo de ejercicio, podrías intentar ejecutar el código del ejemplo que veremos más adelante y quitar
las instrucciones break, con esto podrás comprobar que si el usuario ingresa por ejemplo un 1, se
ejecutarán todos los casos, es por esto que el break es fundamental.
42
Línea 5 a 8
Estas líneas contienen una repetición de las instrucciones de las líneas 3 y 4, evidentemente cada una
contiene un caso distinto, ten en cuenta que se pueden definir todos los casos que sean necesarios al
interior del switch.
Líneas 9, 10 y 12
Estas líneas como deberías saber ya, contienen diferentes comentarios aclarativos sobre el código, en
caso de que no comprendas adecuadamente estas líneas.
Línea 11
Esta línea cambia un poco con respecto a las anteriores, sin embargo, conserva la misma esencia, en
vez de poner el comando "case", usamos el comando "default", y luego los 2 puntos ":", notemos que
no se pone ningún valor a evaluar, pues esta es la acción que se ejecuta en caso de que no lleguemos
a entrar en ninguno de los casos.
Línea 13:
En esta línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya sabrás esta nos
indica que allí termina el bloque del condicional y se dará por terminada la ejecución de este para
continuar ejecutando el resto del programa.
Ejemplos de Condicional Switch en C++

los condicionales Switch en C++, recuerda que, si no comprendes alguno de estos ejemplos o tienes
alguna pregunta o sugerencia sobre estos o cualquier contenido de la sección, puedes preguntar.
43
Ejemplo 1: Menú de opciones en C++
Vamos a retomar el ejemplo mencionado anteriormente al inicio de la sección, en el cual suponíamos
que el usuario nos ingresaba un número correspondiente a una opción cualquiera y de acuerdo a esto
mostramos un mensaje y en caso de ingresar una opción incorrecta, mostramos un mensaje de error.
Primero, determinemos los casos a ejecutar, tenemos tres casos posibles (suponiendo que nuestro
menú está compuesto por 3 opciones) el caso 1 para la opción 1, el dos para la 2 y así sucesivamente.
Nuestro caso por defecto (default) sería el caso de error, que sucede cuando no se ingresa alguna de
las 3 opciones. Veamos entonces como hacer esto:
cout << "Ingrese la Opción a ejecutar: ";

int opcion = 0;
cin >> opcion;
switch(opcion)
{
case 1: cout << "Usted ha seleccionado la opción 1";
break;
break;
break;
default: cout << "Usted ha ingresado una opción incorrecta";
}
44
#include "iostream"
#include "stdlib.h"
int main()
{
cout << "Ingrese la Opción a ejecutar: " <<endl;
int opcion = 0;
cin >> opcion;
switch(opcion)
{
case 1: cout << "Usted ha seleccionado la opción 1" <<endl;
break;
break;
break;
default: cout << "Usted ha ingresado una opción incorrecta" <<endl;
}
system("PAUSE");
return 0;
}
Los condicionales switch de hecho todos los condicionales en sí, son extremadamente útiles pues
permiten definirle a nuestro software múltiples vías de ejecución contemplando así todas las
posibilidades durante la ejecución. Me gustaría hacer una leve aclaración, el condicional switch
encuentra su utilidad al momento de tener más de una posibilidad de valores para una variable
cualquiera, evidentemente si nuestra variable solo puede adquirir un valor útil para nosotros, nuestra
alternativa inmediata debería ser un if o un if-else, no un switch que resulta un poco más engorroso
de escribir, sin embargo cuando tenemos varias posibilidades es mejor un switch que tener
condicionales anidados o un condicional después de otro. Espero que todo te haya quedado claro en
esta sección.
45
Capítulo VI. Los bucles o ciclos en C++. Declaración, uso y sintaxis
de un ciclo en C++
Los ciclos o también conocidos como bucles, son una estructura de control esencial al momento de
programar. Tanto C como C++ y la mayoría de los lenguajes utilizados actualmente, nos permiten hacer
uso de estas estructuras. Un ciclo o bucle permite repetir una o varias instrucciones cuantas veces lo
necesitemos, por ejemplo, si quisiéramos escribir los números del uno al cien no tendría sentido
escribir cien líneas mostrando un numero en cada una, para esto y para muchísimas cosas más, es útil
un ciclo, permitiéndonos hacer una misma tarea en una cantidad de líneas muy pequeña y de forma
prácticamente automática.
Existen diferentes tipos de ciclos o bucles, cada uno tiene una utilidad para casos específicos y
depende de nuestra habilidad y conocimientos poder determinar en qué momento es bueno usar
alguno de ellos. Tenemos entonces a nuestra disposición los siguientes tipos de ciclos en C++:
 Ciclo for en C++
 Ciclo while en C++
 Ciclo do-while en C++
Como mencioné anteriormente, cada uno de estos ciclos tiene ciertas características que lo hacen útil
para algunos casos específicos, a lo largo de los contenidos de esta sección veremos cada uno de estos
al detalle, aprendiendo durante el proceso los componentes, sintaxis y esas características particulares
que permiten decidir cuál usar en qué momento, veremos también el concepto de contador y
acumulador que parte de la existencia de los ciclos
Te recuerdo, que aunque intentaré profundizar bastante en cada concepto, lo haré enfocándome
hacia el uso de los ciclos en el lenguaje C++ y no tanto hacia la parte de la lógica de los ciclos en
particular, si tienes problemas con la correcta comprensión de la lógica y utilidad de cualquier tipo de
ciclo o de los ciclos en general, te invito a que vuelvas a leer las secciones anteriores.
46
Muy bien, ahora que sabemos un poco acerca de las estructuras de control cíclicas (o simplemente
ciclos jeje) y que además sabemos que existen varias, podemos comenzar a aprender y dominar cada
tipo de ciclo en C++, vamos hacerlo en orden, para no enredarnos, así que vamos a la sección de Ciclo
For (o en español ciclo para).
Ciclo for en C++. Estructura, sintaxis y uso de un ciclo for en C++

Los ciclos for son los que se conocen como estructuras de control de flujo cíclicas o simplemente
estructuras cíclicas, estos ciclos, como su nombre lo sugiere, nos permiten ejecutar una o varias líneas
de código de forma iterativa, conociendo un valor especifico inicial y otro valor final, además nos
permiten determinar el tamaño del paso entre cada "giro" o iteración del ciclo.
En resumen, un ciclo for es una estructura de control iterativa, que nos permite ejecutar de manera
repetitiva un bloque de instrucciones, conociendo previamente un valor de inicio, un tamaño de paso
y un valor final para el ciclo.
¿Cómo funciona un Ciclo For?

Para comprender mejor el funcionamiento del ciclo for, pongamos un ejemplo, supongamos que
queremos mostrar los números pares entre el 50 y el 100, si imaginamos un poco como seria esto,
podremos darnos cuenta que nuestro ciclo deberá mostrar una serie de números como la siguiente:
50 52 54 56 58 60 ... 96 98 100. Como podemos verificar, tenemos entonces los componentes
necesarios para nuestro ciclo for, tenemos un valor inicial que sería el 50, tenemos también un valor
final que sería el 100 y tenemos un tamaño de paso que es 2 (los números pares). Estamos ahora en
capacidad de determinar los componentes esenciales para un ciclo for.
Vamos a ver ahora como es la sintaxis de un ciclo for en C++, así estaremos listos para usarlos en
nuestros programas de ahora en adelante.
47
Sintaxis del Ciclo For en C++:
La sintaxis de un ciclo for es simple en C++, en realidad en la mayoría de los lenguajes de alto nivel es
incluso muy similar, de hecho, con tan solo tener bien claros los 3 componentes del ciclo for (inicio,
final y tamaño de paso) tenemos prácticamente todo hecho.
for(int i = valor inicial; i <= valor final; i = i + paso)

{
....
....
Bloque de Instrucciones....
....
....
}
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo for. La sintaxis es simple, tenemos una
variable de control llamada i que es tipo entero (int), cabe notar que la variable se puede llamar como
nosotros lo deseemos y puede ser del tipo de queramos también, sin embargo, en la mayoría de los
casos se usa la "i" como nombre y el entero como tipo, pero somos libres de modificar esto a nuestro
gusto. Esta variable "i" se le asigna un valor inicial que puede ser cualquier número correspondiente
al tipo de dato asignado. Posteriormente lo que haremos será especificar hasta donde irá nuestro ciclo
por medio del valor final, ten en cuenta que cada uno de estos componentes es separado por un punto
y coma ";", también es importante saber que la condición final puede ser cualquier cosa, mayor,
menor, mayor o igual, menor o igual, sin embargo no tiene sentido que la condición sea por ejemplo
un igual, pues nuestra variable de control siempre va a cambiar entre valores, menores o mayores que
el valor final deseado, si fuera un igual no tendríamos un error de sintaxis, pero nuestro for
básicamente no haría nada de nada. Finalmente, el último componente de esta primera línea es el
tamaño del paso, este componente se especifica aumentando en la cantidad deseada la variable de
control.
48
Línea 2:
comienza el bloque de instrucciones que se ejecutaran cada vez que el ciclo de un "giro". Esta llave no
es del todo obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo la
primera línea inmediatamente posterior a la declaración del ciclo, de modo que, si deseamos que se
ejecuten varias líneas dentro de nuestro ciclo, debemos usar las llaves
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo de manera iterativa
durante la ejecución del ciclo, este bloque podrá tener la cantidad de líneas necesarias incluso, como
veremos más adelante dentro de estas podría haber uno o más ciclos, así que podrías tener todo un
programa dentro de un ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya sabrás
esta nos indica que allí termina el bloque del ciclo for y se dará por terminada la ejecución de este
para continuar ejecutando el resto del algoritmo.
No te preocupes si no comprendiste muy bien lo que se acaba de escribir, estoy seguro que con un
par de ejemplos que veremos a continuación, te va a quedar todo claro.
Ejemplos de Ciclo For en C++

los ciclos for en c++, recuerda que, si no comprendes alguno de estos ejemplos o tienes alguna
pregunta o sugerencia sobre estos o cualquier contenido de la sección, se realizaran más ejemplos en
clase.
49
Ejemplo 1: Mostrar en pantalla los números pares
Vamos a retomar el ejemplo anterior, donde deseábamos sacar los números pares entre el número
50 y el 100, es un ejemplo sencillo con el que nos aseguraremos de haber comprendido bien lo
anterior:
Como pudimos ver anteriormente, tenemos entonces que el valor inicial para nuestro ciclo es el
número 50 y el valor final es el 100, además, dado que necesitamos los números pares vamos a ir de
dos en dos, así que el tamaño del paso va a ser 2, teniendo estos 3 componentes identificados,
estamos listos para crear nuestro ciclo for así:
for(int i=50;i<=100;i+=2)
{//Notemos que escribir i+=2 es similar a escribir i = i + 2
cout << i << endl;
}
#include "iostream"
#include "stdlib.h"

int main()
{
for(int i=50;i<=100;i+=2)
{//Notemos que escribir i+=2 es similar a escribir i = i + 2
cout << i << endl;
}
system("PAUSE");
return 0;
}
50
Ejemplo 2: Cuenta regresiva en un ciclo for
Ahora veremos otro ejemplo sencillo en cual veremos que el ciclo for también puede iterar
disminuyendo el valor del contador, para comprender esto, lo que haremos será imprimir por pantalla
una cuenta regresiva desde el número diez hasta el cero, veamos:
Para este caso, debido a que queremos ir de un número mayor a uno más pequeño, por lo tanto, para
este ejemplo el valor inicial será 10 y el valor final será cero. Adicional, el tamaño de paso será de 1
negativo, es decir, -1, así:
for(int i=10;i > 0; i--)

{//Notemos que escribir i-- es similar a escribir i = i - 1
cout < 0; i--)

{//Notemos que escribir i-- es similar a escribir i = i - 1
cout << i << endl;
}
system("PAUSE");
return 0;
}
Este código del ejemplo dos imprimirá por pantalla la serie numérica 10 9 8 7 6 5 4 3 2 1.
51
Ejemplo 3: Contador con un ciclo for
Para este ejemplo haremos algo un poco más complejo. El ejemplo consiste en contar al interior de
un ciclo for, cuántos números entre el 0 y el 10.000 son múltiplos del 13. Para ello haremos uso del
operador % (modulo) que obtiene el residuo de una división y también usaremos un pequeño
condicional para verificar que el modulo sea cero al dividir por 13.
Para este caso el valor inicial será 0 y el valor final será 10000. Adicional, el tamaño de paso será de 1.
Al interior del ciclo, en cada iteración verificaremos si el número en el que estamos es divisible por
trece o no y en caso afirmativo aumentaremos el contador en una unidad así:
int contador = 0; //Iniciamos el contador en cero

for(int i = 0; i < 10000; i++)
{//Notemos que escribir i++ es similar a escribir i = i + 1
if(i%13 == 0) //Si el residuo es cero es múltiplo de 13
{
contador++; //Si es múltiplo aumentamos el contador en 1
}
}
//Mostramos el contador después de verificar todos los números
cout << contador << endl;
52
#include "iostream"
#include "stdlib.h"

int main()
{
int contador = 0; //Iniciamos el contador en cero
for(int i = 0; i < 10000; i++)
{ //Notemos que escribir i++ es similar a escribir i = i + 1
if(i%13 == 0) //Si el residuo es cero es múltiplo de 13
{
contador++; //Si es múltiplo aumentamos el contador en 1
}
}
//Mostramos el contador después de verificar todos los números
cout << contador << endl;
system("PAUSE");
return 0;
}
Este ciclo for nos permitirá saber que existen 770 múltiplos del 13 en los números del 0 al 10000.
En efecto los ciclos for, son bastante útiles, sin embargo, desde el punto de vista de la eficiencia, es
recomendable evitarlos en la medida de lo posible, siempre que vayas a usar un ciclo for, deberías
preguntarte primero si es totalmente necesario o si existe una manera más efectiva de hacerlo.
Evidentemente habrá situaciones en las que será casi que imprescindible usar el ciclo for, pues por
algo existen. Está entonces en nuestra habilidad determinar cuándo usarlos y mejor aún cómo usarlos
de manera efectiva.
53
Ciclo while en C++. Estructura y sintaxis. Cómo y para qué usar un ciclo while en C++
Los ciclos while son también una estructura cíclica, que nos permite ejecutar una o varias líneas de
código de manera repetitiva sin necesidad de tener un valor inicial e incluso a veces sin siquiera
conocer cuándo se va a dar el valor final que esperamos, los ciclos while, no dependen directamente
de valores numéricos, sino de valores booleanos, es decir su ejecución depende del valor de verdad
de una condición dada, verdadera o falso, nada más. De este modo los ciclos while, son mucho más
efectivos para condiciones indeterminadas, que no conocemos cuando se van a dar a diferencia de los
ciclos for, con los cuales se debe tener claro un principio, un final y un tamaño de paso.
¿Cómo funciona un Ciclo While?

Para comprender mejor el funcionamiento del ciclo while, pongamos un buen ejemplo, imaginemos
que, por algún motivo, queremos pedirle a un usuario una serie de números cualquiera y que solo
dejaremos de hacerlo cuando el usuario ingrese un número mayor a 100. Como vemos, aquí no
podríamos utilizar un ciclo for, pues no tenemos ni idea de cuándo al usuario se le va a ocurrir ingresar
un número mayor que 100, es algo indeterminado para nosotros, sin embargo, el ciclo while nos
permite ejecutar una acción de forma infinita hasta que se cumpla alguna condición específica, en
nuestro caso sería que el número ingresado sea mayor a 100. De modo que si el usuario nos ingresa
de manera sucesiva los siguientes números 1, 50, 99, 49, 21, 30, 100 ..., nuestro programa no finalizara,
pues ninguno de estos números es mayor que 100, sin embargo si nos ingresara el número 300, el
programa finalizaría inmediatamente.
Vamos a ver ahora como es la sintaxis de un ciclo while en C++, así estaremos listos para usarlos en
nuestros programas de ahora en adelante cada vez que lo necesitemos.
Sintaxis del Ciclo While en C++:

La sintaxis de un ciclo while es incluso más simple y "legible" que la del ciclo for en C++, pues
simplemente requerimos tener clara una condición de parada. En realidad, en la mayoría de los
lenguajes de alto nivel la manera de escribir un ciclo while (la sintaxis) es incluso muy similar, así que
54
con tan solo tener bien clara una condición de finalización para el ciclo tendremos prácticamente todo
hecho.
while(condición de finalización) //por ejemplo numero == 100

{
....
....
....
....
}
Vamos entonces a ver línea por línea el anterior código para comprender todo y quedar claros.
Posteriormente veremos el ejemplo planteado anteriormente y su solución.
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo while. La sintaxis es bastante simple.
Tenemos al interior de los paréntesis una condición cualquiera, es decir por ejemplo "==, >, <, >=, <=,
!=" o algunas más que se nos puedan ocurrir, esta condición que especifiquemos allí, es la que
permitirá que el ciclo se siga ejecutando hasta que en algún momento esta misma condición deje de
cumplirse, de esta forma si por ejemplo estamos verificando que un numero_cualquiera == 50, el ciclo
se ejecutara solo cuando numero_cualquiera sea igual a 50, en cuanto su valor cambie a cualquier
otro el ciclo while finalizara y continuara con el resto de la ejecución del programa. De esta forma, es
evidente que la condición que allí ingresemos siempre deberá tomar un valor booleano (true o false).
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí comienza un bloque
de instrucciones que se ejecutaran cada vez que el ciclo de un "giro". Esta llave no es del todo
obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo while la primera
línea inmediatamente posterior a la declaración del ciclo, de modo que, si deseamos que se ejecuten
varias líneas dentro de nuestro ciclo, debemos usar las llaves.
55
Línea 3 a 7:
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya debemos
saber esta nos indica que allí termina el bloque del ciclo while y se dará por terminada la ejecución de
este para continuar ejecutando el resto del algoritmo.
Ejemplos de Ciclo While en C++

los ciclos while en c++, recuerda que, si no comprendes alguno de estos ejemplos o tienes alguna
pregunta o sugerencia tendrás que hacerlo en el salón.
Ejemplo 1: Pedir números por pantalla hasta que alguno sea mayor a 100
Vamos a retomar el ejemplo anterior, donde queremos hacer que nuestro programa le pida a un
usuario una serie de números cualquiera y que solo dejaremos de hacerlo cuando el usuario ingrese
un número mayor a 100, una vez más es un ejemplo sencillo con el que nos aseguraremos de haber
comprendido bien todos los conceptos anteriores:
Para solucionar esto, debemos tener clara cuál va a ser la condición que se debe cumplir para que el
ciclo este pidiendo el numero contantemente, el ciclo se va a detener solo cuando el numero ingresado
sea mayor que 100, así que la condición para que se siga ejecutando es que el numero sea menor a
56
100, ¿Comprender la lógica?, es simple si para que se detenga el numero debe ser mayor a 100,
entonces para seguirse ejecutando el numero debe ser menor o igual a 100, veámoslo entonces.
int numero;
cin >> numero;
while(numero <= 100)
{
cout << "Ingrese un numero ";
cin >> numero;
}
El código funcional completo y un tanto más amigable para el usuario sería el siguiente:
#include "iostream"
#include "stdlib.h"

int main()
{
int numero;
cout << "Ingrese un numero " <<endl;
cin >> numero;
while(numero <= 100)
{
cout << "Ingrese un numero " <<endl;
cin >> numero;
}
system("PAUSE");
return 0;
}
En efecto los ciclos while, son bastante útiles, sin embargo, desde el punto de vista de la eficiencia al
igual que con los ciclos for, es recomendable evitarlos en la medida de lo posible, siempre que vayas
a usar un ciclo while o cualquier tipo de ciclo en realidad, deberías preguntarte primero si es
totalmente necesario o si existe una manera más efectiva de hacerlo. Evidentemente habrá
situaciones en las que será casi que imprescindible usar el ciclo, pues por algo existen, esta entonces
en nuestra habilidad determinar cuándo usarlos y mejor aún como usarlos de manera efectiva.
57
Ciclo do-while en C++. Estructura y sintaxis. Cómo y para qué usar un ciclo do-while
en C++
Los ciclos do-while son una estructura de control cíclica, los cuales nos permiten ejecutar una o varias
líneas de código de forma repetitiva sin necesidad de tener un valor inicial e incluso a veces sin siquiera
conocer cuándo se va a dar el valor final, hasta aquí son similares a los ciclos while, sin embargo el
ciclo do-while nos permite añadir cierta ventaja adicional y esta consiste que nos da la posibilidad de
ejecutar primero el bloque de instrucciones antes de evaluar la condición necesaria, de este modo los
ciclos do-while, son más efectivos para algunas situaciones específicas. En resumen, un ciclo do-while,
es una estructura de control cíclica que permite ejecutar de manera repetitiva un bloque de
instrucciones sin evaluar de forma inmediata una condición específica, sino evaluándola justo después
de ejecutar por primera vez el bloque de instrucciones.
¿Cómo funciona un Ciclo Do-While?

Para comprender mejor el funcionamiento del ciclo while, usemos de nuevo el ejemplo de la sección
anterior sobre el ciclo while. Imaginemos entonces que, por algún motivo, queremos pedirle a un
un número mayor a 100. Como vimos anteriormente, esto se puede hacer por medio de un ciclo while,
pero vamos ahora a ver como lo podemos hacer usando un ciclo do-while mejorando así un poco
nuestro algoritmo, evitando ciertos comandos, tal como se dijo con el ciclo while, en efecto aquí
estamos en la situación de no tener ni idea de cuándo al usuario se le va a ocurrir ingresar un número
mayor que 100, pues es algo indeterminado para nosotros, sin embargo el ciclo while y en efecto el
do-while nos permite ejecutar cierta acción de forma infinita hasta que se cumpla alguna condición
específica, en nuestro caso sería que el numero ingresado sea mayor a 100. De modo que si el usuario
nos ingresa de manera sucesiva los siguientes números 1, 50, 99, 49, 21, 30, 100 ..., nuestro programa
no finalizara, pues ninguno de estos números es mayor que 100, sin embargo, si nos ingresara el
número 300, el programa finalizaría inmediatamente.
Vamos a ver ahora como es la sintaxis de un ciclo do-while en C++, así estaremos listos para usarlos
en nuestros programas de ahora en adelante cada vez que lo necesitemos.
58
Sintaxis del Ciclo Do-While en C++:
La sintaxis de un ciclo do-while es un tanto más larga que la del ciclo while en C++, sin embargo, no se
hace más complicado, de hecho, con tan solo tener bien clara una condición de finalización para el
ciclo tendremos prácticamente todo terminado.
do
{
....
....
....
....
}
while(condición de finalización); //por ejemplo numero != 23
Vamos entonces a ver línea por línea el anterior código para comprender todo y quedar claros.
Posteriormente veremos el ejemplo planteado anteriormente y su solución.
Línea 1:
Esta línea es por decirlo así, la parte novedosa del ciclo do-while, esta expresión no evalúa ninguna
condición ni nada, simplemente da paso directo al bloque de instrucción y luego permite la evaluación
de la condición.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí comienza un bloque
de instrucciones que se ejecutaran cada vez que el ciclo de un "giro". Esta llave no es del todo
obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo la primera línea
inmediatamente posterior a la instrucción do, de modo que, si deseamos que se ejecuten varias líneas
dentro de nuestro ciclo, debemos usar las llaves. En lo personal, es preferible poner siempre las llaves
sin importar cuantas líneas se vayan a ejecutar, es una buena práctica de programación y te puede
evitar dolores de cabeza.
59
Línea 3 a 7:
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya debemos
saber esta nos indica que allí termina el bloque de instrucciones que se ejecutarán de manera cíclica
y se dará por terminada la ejecución de este para continuar ejecutando el resto del algoritmo.
Línea 9:
La línea 9 en el ciclo do-while, tiene la misma importancia y función que la linea 1 en la sección del
ciclo while, cabe resaltar que simplemente evalúa la condición y define si se cumple o no para seguir
con la ejecución del ciclo o con la del resto del algoritmo, de este modo podemos ver que el ciclo while
y el do-while son muy similares, con la pequeña diferencia en que en uno se evalúa la condición desde
el principio y en la otra al final de cada ciclo.
Ejemplos de Ciclo Do-While en C++

los ciclos while en c++.
Ejemplo 1: Pedir números por pantalla hasta que alguno sea mayor a 100
Vamos a retomar el ejemplo anterior, donde queremos hacer que nuestro programa le pida a un
un número mayor a 100, una vez más es un ejemplo sencillo con el que nos aseguraremos de haber
comprendido bien todos los conceptos anteriores, vamos a ver cómo hacer lo mismo con dos tipos de
ciclos diferentes (el while y el do-while), sin embargo, vamos a ver como con uno es más eficiente que
con el otro:
60
Para solucionar esto, debemos tener clara cuál va a ser la condición que se debe cumplir para que el
ciclo este pidiendo el numero constantemente. El ciclo se va a detener solo cuando el numero
ingresado sea mayor que 100, así que la condición para que se siga ejecutando es que el número sea
menor a 100, ¿Comprender la lógica?, es simple si para que se detenga el numero debe ser mayor a
100, entonces para seguirse ejecutando el numero debe ser menor o igual a 100, veámoslo entonces.
int numero;
do
{
cin >> numero;
}
while(numero <= 100);
El código funcional completo y un tanto más amigable para el usuario sería el siguiente:
#include "iostream"

int main()
{
int numero;
do
{
cin >> numero;
}
while(numero <= 100);
system("PAUSE");
return 0;
}
Como podrás comprobar, ambos códigos hacen lo mismo, haciendo uso del ciclo while o del ciclo do
while, sin embargo con el ciclo do-while, hemos obtenido un beneficio interesante, primero que todo
hemos podido evitar tener que inicializar la variable número, segundo también pudimos eliminar las
líneas repetidas donde se pedía el numero por fuera del ciclo y luego al interior del ciclo, aquí lo
hicimos solo al interior, pues la condición se evaluaba mucho más abajo.
61
En efecto los ciclos do-while, son bastante útiles, sin embargo, como con cualquier ciclo desde el punto
de vista de la eficiencia al igual que con los ciclos for, es recomendable evitarlos en la medida de lo
posible, siempre que vayas a usar un ciclo do-while o cualquier tipo de ciclo en realidad, deberías
preguntarte primero si es totalmente necesario o si existe una manera más efectiva de hacerlo.
Evidentemente habrá situaciones en las que será casi que imprescindible usar el ciclo, pues por algo
existen, está entonces en nuestra habilidad determinar cuándo usarlos y mejor aún como usarlos de
manera efectiva.
Ciclos anidados en C++. Creando ciclos al interior de otros ciclos

Antes de comenzar, quisiera aclarar que los ciclos anidados NO son en sí una estructura de control,
son de hecho un conjunto de estructuras de control anidadas, con anidadas me refiero a que una está
dentro de la otra. De este modo un ciclo anidado (de hecho, debería ser ciclos anidados, en plural: P)
no es más que uno o más ciclos dentro de otro y de hecho no tenemos límite alguno para la cantidad
de ciclos anidados.
Uno de los mayores problemas en cuanto a eficiencia que hay en la programación es tener ciclos
anidados, son simplemente terribles para el rendimiento, sin embargo, hay ocasiones en las que son
indispensables. Como mencioné, no existe límite para la cantidad de ciclos anidados, sin embargo,
entre más ciclos tengamos, uno dentro de otro, más lenta será nuestra ejecución.
En conclusión, los ciclos anidados no son una estructura de control por sí mismos, son un indicativo
de que quizá deberíamos plantear la solución a algún problema si nos vemos obligados a usar ciclos
anidados y más aún si es más de uno, sin embargo, debemos saber que a veces son indispensables.
Hechas las aclaraciones previas en cuanto a rendimiento y definición vamos a ver unos ejemplos y el
código básico de ciclos anidados en C++.
62
¿Cómo funciona un ciclo anidado?
Un único ciclo al interior de otro, funciona como un ciclo normal pero elevado al cuadrado, el ciclo
externo comienza su ejecución con normalidad y luego va hasta el ciclo interno, y aquí es donde
cambia todo; el ciclo externo no avanza hasta que el ciclo interno termine y una vez el ciclo externo
avanza un paso vuelve a esperar al interno y así sucesivamente hasta que el externo termina, es por
esto que es tan ineficiente el asunto.
Los ciclos anidados suelen usarse para llenar matrices (un vector de varias dimensiones) donde un
ciclo recorre cada fila y otro cada columna o viceversa (depende de lo que necesitemos). De este modo
entonces el ciclo externo empieza por la columna cero y el interno llena cada casilla de la columna
cero y luego de la uno y las dos y así...
Notemos que entonces el ciclo externo (el de las columnas) no avanza a la siguiente hasta que el ciclo
interno no llene todas las casillas de esa columna (lo cual tiene sentido, pues debe llenarse en orden).
Sintaxis de ciclos anidados:

La sintaxis es sencilla, un ciclo con otro adentro, y lo que nos haga falta, pues podemos poner varias
sentencias adicionales al interior de cualquiera de los dos ciclos.
for(int i = valor inicial; i < valor final; i++)

{
/*
....
....
*/
for(int j = valor inicial; j < valor final; j++)
{
/*
....
Bloque interno de Instrucciones....
....
*/
}
//Acá pueden haber más instrucciones
}
63
Como puedes ver entonces, es bastante simple, solo hay que notar algunas cosas interesantes: la
primera y más importante es que la variable de control debe ser distinta en cada ciclo, fíjate que el
ciclo externo usa la variable 'i' como variable de control mientras que el ciclo interno usa la 'j'. También
debes notar que en el bloque interno de instrucciones podrías poner otro ciclo de cualquier tipo y al
interior de este otro y así sucesivamente, cambiando el nombre de la variable de control (usar 'k' por
ejemplo) para evitar mal funcionamiento. Finalmente debes saber que, aunque son ciclos anidados no
dejan de ser ciclos independientes en realidad, así que puedes poner las instrucciones que desees al
interior de cualquier de ellos.
Cabe mencionar que no se ha hablado de tipos de ciclos, en realidad somos libres de anidar cualquier
tipo de ciclo (for, while, do-while) y en cualquier cantidad, por ejemplo:
while(condición)
{
/*
*/
for(int i = valor inicial; j < valor final; j++)

{
/*
Bloque interno de Instrucciones....
*/
while(condición2)
{
/*
Más instrucciones
*/
}
}
//Acá pueden haber más instrucciones
}
Como puedes notar, básicamente no tienes restricciones en ello, de hecho, al interior de cada ciclo
puedes poner condicionales y demás estructuras que requieras.
Veamos entonces un ejemplo funcional para quedar claros.
64
Ejemplo de ciclos anidados en C++
Como quizá habrás adelantado en este primer ejemplo vamos a llenar una matriz de 10x10 (diez filas
y diez columnas) con los números del 1 al 100 (1x1 hasta 10x10).
#include "iostream"
#include "stdlib.h"
int main()
{
int matriz[10][10];
for(int i = 0; i < 10; i++) //Ciclo externo

{
//Notemos que en ciclo interno no usamos la variable 'i' sino 'j'
//Si usaramos i, el comportamiento sería inesperado
for(int j = 0; j < 10; j++)//Ciclo interno
{
//Llenamos la matríz con los números del 1 al 100
matriz[i][j] = (i+1)*(j+1);
cout<<"Matriz[" <<i <<"]["<<j <<"] = " <<matriz[i][j] <<"\n";
//(i+1)*(j+1) va desde 1x1 hasta 10x10 (aunque en desorden)
}
}
system("pause");
return 0;
}
65
Segundo ejemplo de ciclos anidados en C++
Ahora vamos a hacer la función complementaria, vamos a recorrer la matriz usando ciclos anidados y
a mostrar los valores en ésta.
#include "iostream"
int main()
{
//Suponiendo que tenemos una matríz llena llamada matrix
{
//Recuerda: En ciclo interno no usamos la variable 'i' sino 'j'
for(int j = 0; j < 10; j++) //Ciclo interno
{
//Mostramos por pantalla el valor de la fila i columna j
cout << matriz[i][j] << "\n";
}
}
system("pause");
return 0;
}
Ten en cuenta que este ejemplo no funcionaría por sí solo, puesto que estamos recorriendo una matriz
que ya está llena (como lo hicimos en el primer ejemplo). El código completo funcional, donde
llenamos y luego mostramos la matriz, sería el siguiente:
66
Ejemplo completo y funcional
Vamos entonces a juntar ambos códigos para realizar ambas tareas (recorrer y mostrar la matriz)
usando ciclos anidados.
#include "iostream"
#include "stdlib.h"
int main()
{
int matriz[10][10];

{
//Notemos que en ciclo interno no usamos la variable 'i' sino 'j'
//Si usaramos i, el comportamiento sería inesperado
{
//Llenamos la matríz con los números del 1 al 100
matriz[i][j] = (i+1)*(j+1);
//(i+1)*(j+1) va desde 1x1 hasta 10x10
}
}

{
{
//Mostramos por pantalla el valor de la fila i columna j
cout << matriz[i][j] << "\n";
}
}
system("pause");
return 0;
}
En efecto los ciclos anidados son muy interesantes y también útiles para múltiples situaciones, pero
debes recordar que el tema de la eficiencia es un poco delicado, es recomendable evitarlos, aunque
no temerles, pues hay casos en los que son fundamentales e indispensables. Cuando vayas a usar un
ciclo anidado detente un par de minutos y piensa si es realmente necesario usarlo o si puede haber
67
una manera más efectiva de conseguir el mismo resultado; repito: habrá casos en los que sea
indispensable usarlos, así que no les temas pues en algún momento será imprescindible usar un
hermoso ciclo anidado, pues por alguna razón el lenguaje nos permite crearlos. Así que será nuestra
experiencia y pericia la que nos dirá cuándo es realmente necesario usarlos.
Capítulo VII. Estructuras de datos en C++. Uso, manejo y ventajas.

Arreglos, vectores, matrices y demás.
Las estructuras de datos en C++ se pueden entender como un tipo de dato compuesto (no complejo).
Las estructuras de datos permiten almacenar de manera ordenada una serie de valores dados en una
misma variable. Las estructuras de datos más comunes son los vectores o arreglos y las matrices,
aunque hay otras un poco más diferentes como son el struct y las enumeraciones.
En esta serie de contenidos aprenderemos de éstas con detalle. Las estructuras de datos han sido
creadas para solucionar una gran variedad de problemáticas que no eran solucionables (o al menos
no muy fácilmente) con los tipos de datos primitivos. Tal como mencioné hace un momento las
estructuras de datos se pueden ver como una agrupación o estructuración para una serie de tipos de
datos primitivos (aunque también pueden poseer tipos de datos complejos) que pueden ser
fácilmente utilizadas e identificadas. Sin la existencia de las estructuras de datos sería imposible o
bastante complicado por ejemplo conocer y manejar todos los números de identificación, nombres y
direcciones de todos los usuarios de un sistema (que normalmente serían muchísimos) pero ahora con
las estructuras de datos es muy simple definir una serie de posiciones en memoria para cada valor que
deseamos guardar o definir un orden o valores específicos para cada campo y accediendo a ellos
generalmente por medio de una única variable, todo esto es sencillo hacerlo con el uso de las
estructuras de datos y sin desperdiciar recursos. Vamos entonces a comenzar con la sección de
arreglos o vectores para comprender mejor de lo que estoy hablando.
68
Arrays, arreglos o vectores en C++. Uso, declaración y sintaxis de los vectores en C++
Los arrays, arreglos o vectores forman parte de la amplia variedad de estructuras de datos que nos
ofrece C++, siendo además una de las principales y más útiles estructuras que podremos tener como
herramienta de programación. Los arrays, arreglos o vectores (como los quieras llamar), son utilizados
para almacenar múltiples valores en una única variable. En un aspecto más profundo, los arrays,
permiten almacenar muchos valores en posiciones de memoria continuas, lo cual permite acceder a
un valor u otro de manera rápida y sencilla. Estos valores pueden ser números, letras o cualquier tipo
de variable que deseemos incluso tipos de datos propios.
En múltiples ocasiones es necesario almacenar gran cantidad de información en una variable y a

menudo sucede que no conocemos con exactitud la cantidad de datos que debemos almacenar, pero
sabemos que sí sería más de uno, como por ejemplo almacenar las identificaciones de las personas
ingresadas al sistema. Los arrays, arreglos o vectores son una estructura que nos permite solucionar
este tipo de problemas. Para explicar mejor de lo que hablo, pongamos un ejemplo:
Ejemplo de Arrays o Vectores en C++

Imaginemos que queremos crear un programa con el cual podamos de algún modo almacenar los
títulos y los autores de diferentes libros. El usuario es el encargado de suministrar la información de
cada libro, así entonces, dado que es el usuario quien lo hace, nosotros no tenemos manera alguna de
saber cuántos libros va querer él ingresar por medio de nuestro programa. El caso principal es que
queremos almacenar en la memoria el título y el autor de TODOS y cada uno de los libros. Entonces
¿cómo crees que podrías hacer esto? Con lo que sabemos hasta hora, se nos podrían ocurrir un par
de cosas. Veamos:
Posible Solución 1: Sin usar vectores (errónea):

Podríamos pensar primero, "listo, está bien, es fácil, declaro una variable llamada título y otra autor,
ambas de tipo string y se las pido al usuario", pues bien, esta solución digamos que nos permite
almacenar la información del primer libro que el usuario ingrese, pero en cuanto desee ingresar otro
libro ¿qué vamos a hacer?, si lo hacemos así, cuando el usuario ingrese la información para un nuevo
69
libro, va a sobrescribir los valores anteriores y habremos perdido la información del primero, de
manera que esta solución no es válida.
Posible Solución 2: Sin usar vectores o matrices (errónea):

Pensando un poco más en esto, se nos ocurre una forma de almacenar la información de cada libro,
podríamos crear un par de variables distintas para cada libro. Pero de inmediato nos damos cuenta
que si por ejemplo al usuario se le cruzara por la cabeza ingresa información para 10 libros tendríamos
entonces ¡20 variables distintas!, 2 por cada libro, no es mucho, pero si se le ocurriera ingresar 1000
libros, ¿estarías dispuesto a declarar 2000 variables? De modo que esta alternativa es incluso peor
que la anterior y seguimos aún sin solucionar nuestro problema.
Posible Solución 3: Usando vectores o matrices (correcta):

¡Pues bien!, tal y como mencioné antes, los arrays o los vectores han venido para ayudarnos en
múltiples circunstancias similares a esta. Dado que un array, arreglo o vector es capaz de almacenar
múltiples valores en una misma variable, tenemos el elemento perfecto para almacenar la información
de todos los libros, podremos crear un vector de un tamaño cualquiera capaz de contener en sí los
nombres de los autores y otro con los títulos de los libros o alternativamente podríamos crear una
matriz de dos columnas que contenga en la primera columna los autores y en la segunda los títulos;
ambas soluciones son válidas y vamos a ver ambas, usando vectores en esta sección y usando matrices
en la sección de matrices.
En C++, a diferencia de algunos otros lenguajes de programación, los vectores y las matrices presentan
un "inconveniente" con el tamaño. Es decir, no es posible crear de una manera sencilla un vector capaz
de almacenar una cantidad de información indefinida, es necesario ingresar con antelación la cantidad
de datos (tamaño) que el vector o la matriz tendrá. Este problema se puede solucionar, pero es algo
que no veremos en esta sección.
Muy bien, ahora que sabemos la gran utilidad de los arrays, vectores o arreglos para nosotros,
aprendamos más acerca de estos, veamos como declarar un vector, array o arreglo, como recorrer un
vector y algunos ejemplos de esto.
70
¿Cómo declarar un Array o Vector en C++?
Para declarar un vector en C++, se deben seguir las mismas normas básicas que se siguen para declarar
una variable cualquiera, con un pequeño cambio en la sintaxis. Para declarar un vector, arreglo o como
lo quieras llamar, necesitaremos saber el tipo de los datos que irán al interior de este, es decir, serán
número enteros, o numero decimales o cadenas de texto, etc. necesitamos también, como siempre,
un nombre para el vector y un tamaño máximo. La sintaxis para declarar un vector en C++ es la
siguiente:
tipo_de_dato nombre_del_vector[tamaño];
Tenemos entonces, tal como mencioné antes, que, para declarar un vector en C++, debemos definirle
un tipo de los datos, sea entero, float, string, etc., debemos darle un nombre y al interior de los
corchetes "[]" debemos poner el tamaño máximo que tendrá el vector, es decir la cantidad máxima
de datos que podrá contener (recuerda que en C++ esto es necesario hacerlo). Veamos un ejemplo en
el cual pondré la declaración de varios vectores de diferentes tipos y tamaños en C++.
Declaración de un Array o Vector en C++
int my_vector1[10];
float my_vector2[25];
string my_vector3[500];
bool my_vector4[1000];
char my_vector5[2];
Veamos rápidamente que representa cada línea del código anterior.
Línea 1
Esta línea contiene la declaración de un vector llamado my_vector1, el cual contendrá un máximo de
10 elementos de tipo entero.
71
Línea 2
25 elementos de tipo float.
Línea 3
500 elementos de tipo string.
Línea 4
1000 elementos de tipo booleano.
Línea 5
2 elementos de tipo char.
Ya que está claro cómo se declara un vector, vamos a ver cómo inicializarlo, es decir inicializar un
vector en C++ o en otras palabras darle valores a un vector.
¿Cómo inicializar un Array o Vector en C++?

En cuanto tenemos declarado un vector, es posible asignarle valores, evidentemente estos valores
deben coincidir con el tipo de dato que le asignamos a dicho vector, no tendría sentido ingresar como
valores de un vector cadenas de caracteres si el tipo de dato de dicho vector es numérico.
Voy a mostrar a continuación formas distintas de inicializar un vector, todas son válidas, ya es cuestión
de nuestras necesidades y conocimientos determinar cuál es útil y en qué momento. Veamos
entonces:
72
Forma 1 de declarar un Array o Vector en C++
string vector[5] = {"5", "hola", "2.7", "8,9", "adios"};
Aquí hemos declarado un vector de tipo string tamaño 5 y lo hemos inicializado con diferentes valores,
es necesario notar que cada valor va entre comillas dobles "" puesto que son strings. El valor inicial
corresponde a la casilla o índice 0 y tiene el valor de "5", el índice 1 el valor es "hola" y el índice 4 el
valor es "adiós", es importante notar que el primer índice de n array o vector no es el UNO sino que
es el CERO.
Forma 2 de declarar un Array o Vector en C++
int vector2[] = {1,2,3,4,10,9,80,70,19};
Aquí hemos declarado un vector de tipo int y no especificamos su tamaño, si el tamaño no se especifica
entre los corchetes, el vector tendrá como tamaño el número de elementos incluidos en la llave, para
este caso es 9.
Particularidades de los Arrays, arreglos o Vectores en C++

Con C++, existen algunas particularidades, en cuanto a la declaración de vectores, que me parece
importante destacar para que en momento de quizá caer en ellas comprender como podrían cambiar
las cosas o básicamente en que consiste el error, veamos:
Particularidad 1 al momento de declarar o inicializar un Vector o Array en C++
int vector2[3];
vector2[3] = {1,5,10};
Dadas las características de C++, es fácil pensar que es factible crear o declarar un vector de un tamaño
cualquiera y posteriormente inicializarlos de forma habitual como se muestra en este código, sin
embargo, hacer esto es un error, si declaramos un vector y no lo inicializamos inmediatamente, no es
posible inicializarlo de la forma que hemos visto, es decir entre llaves cada valor, como en la línea 2
73
del código anterior. La única forma de inicializar el vector o, mejor dicho, darle valores a cada una de
sus casillas, es hacerlo uno por uno, es decir darle un valor a la casilla cero a la uno y a la 2 (para un
vector de tamaño 3). Por defecto, al declarar un vector sin ser inicializado, cada una de las casillas de
este vector toma como valor el valor por defecto del tipo de variable, para el caso de los enteros (int)
es -858993460. Así entonces para asignar valores a cada casilla lo hacemos así:
int vector2[3];
vector2[0] = 1;
vector2[1] = 3;
vector2[2] = 10;
Es importante notar en este código, que el número que va entre corchetes ya no indica tamaño (pues
vector2 ya está declarado) sino que indica el índice o el número de la casilla con la cual estaremos
operando (recordemos que el primer índice es cero y no uno), en el código anterior, habíamos
declarado un vector de tamaño 3, por lo cual debíamos asignar valores a los índices 0, 1 y 2.
Particularidad 2 al momento de declarar o inicializar un Vector o Array en C++
float vector3[5] = {10.5};
En C++ a la hora de inicializar un array, arreglo o Vector, estamos acostumbrados a que si inicializamos
inmediatamente después de declarar el vector, debemos poner la misma cantidad de elementos al
interior de las llaves de manera que corresponda con el tamaño del vector, pues bien, esto es lo más
recomendable, sin embargo si ponemos una cantidad de elementos menor a la del tamaño real del
vector, estamos queriendo decir que estos elementos toman los valores puestos entre las llaves y los
demás serian cero, para el caso del código anterior el primer elemento (el del índice cero) va a tener
un valor de 10.5 y los otros 4 elementos van a valer cero.
Ya tenemos claro cómo declarar un array o vector en C++, algunas características un tanto particulares
de estos, sin embargo, aún no sabemos cómo obtener los datos de un array, es decir una vez el array
o vector este lleno con los elementos que queremos, como podemos obtener esa información y más
aún, como obtener un valor específico dentro del array. Veámoslo:
74
Obtener el valor de una casilla específica en un array en C++
Es muy común el caso en el que tenemos un vector con una enorme cantidad de elementos, sin
embargo, de todos estos, solo nos interesa uno en especial y corremos con la suerte de saber cuál es
su índice, sabiendo el índice de un elemento en un array es bastante sencillo obtener el valor de este:
float vector4[5] = {10.5, 5.1, 8.9, 10, 95.2}; //Array con 5 elementos
float numero5 = vector4[4]; //Para acceder al elemento 5, se usa el índice 4
float primerNumero = vector4[0]; //Para el primer elemento se usa el índice 0
Como podemos ver, para acceder a un valor específico conociendo el índice del elemento, solo basta
con escribir dicho índice entre los corchetes "[ ]", recuerda que el índice comienza desde cero, así por
lo tanto en un vector de 5 elementos (como el del ejemplo), el último elemento está en el índice 4 y
el primer elemento del array en el índice 0.
Ya tenemos entonces una forma de acceder de forma individual a un elemento de un array o vector,
vamos a ver ahora como recuperar todos los elementos de un vector de forma simple.
Recorrer un Array o Vector en C++

Para obtener todos los datos que se encuentran al interior de un vector, es necesario recorrer el array
o vector, para recorrerlo, se usa casi siempre un ciclo for, en algunos casos más específicos un ciclo
while, pero generalmente el ciclo for es el ideal para esto, dado que conocemos el tamaño del array.
La lógica de este procedimiento es la siguiente, el ciclo for comenzara desde cero e ira hasta el tamaño
del vector, de modo que la variable de control que generalmente llamamos "i", será la que va a ir
variando entre cero y el tamaño del array, de esta forma al poner la i al interior de los corchetes,
estaremos accediendo al valor de cada casilla del vector y podremos hacer lo que sea necesario con
dicho valor, veamos:
75
A veces no es posible determinar con facilidad el tamaño exacto de un vector, pero en C++ existen
varias formas de determinar el tamaño de un array o vector fácilmente, aquí explicare un método.
Cabe notar que este tamaño es el que ira como tope del ciclo for y sería equivalente a que nosotros
mismos, en caso de saber el tamaño del vector, lo pongamos allí, sin embargo, como veremos en otra
sección no siempre es posible saber con certeza el tamaño de un vector.
#include "iostream"
int main()
{
int edades[] = {1,2,9,8,16,32,9,50,36,20,1,87};
int limite = (sizeof(edades)/sizeof(edades[0]));
for (int i = 0; i < limite; i++)
{
cout<<edades[i]<<endl;
}
}
Vamos a ver de forma resumida en qué consiste y que hace cada una de estas líneas:
Línea 1:
Tenemos en la primera línea la declaración de un vector que contiene las edades de 12 personas,
notemos que entre los corchetes no se puso ningún número, pues no es necesario, ya que el vector
tendrá el tamaño según la cantidad de elementos que declaremos entre las llaves, evidentemente si
pusiéramos un 12 entre los corchetes, no habría ningún problema.
Línea 2:
En la segunda línea, tenemos la declaración del límite del ciclo o en otras palabras el tamaño del array.
El tamaño de un array se puede calcular de varias formas, aquí lo obtenemos calculando el tamaño
del array entero, dividido por el tamaño del primer elemento de dicho array, para más detalles de
esto, verifica la información sobre el operador sizeof.
76
Línea 3 a 6:
Desde la tercera línea hasta la sexta, tenemos entonces un ciclo for que comienza en cero y termina
en el límite (es importante notar que la condición usada es estrictamente menor "<" y no menor o
igual "<="), al interior de este ciclo, es donde accedemos a cada uno de los elementos del vector por
medio de la sintaxis explicada anteriormente
Línea 5:
La quinta línea es quizá la más vital, aunque sin las demás no tendríamos nada. En esta línea, estamos
accediendo a cada uno de los elementos del array de edades, un elemento por cada vuelta que da el
ciclo, accedemos a cada elemento poniendo entre los corchetes la variable i, que es la que está
cambiando a medida que el ciclo va girando, así estaremos accediendo a todos los elementos e
imprimiéndolos por pantalla
Muy bien, llego el momento de afianzar nuestros conocimientos viendo un ejemplo. Ahora que
tenemos claro como declarar un vector en C++, como recorrerlo y como acceder a sus datos, vamos a
ver un ejemplo basado en el problema que planteé al inicio de esta sección (el de los libros).
Ejemplo 1 de Arrays o Vectores en C++

El problema es simple, queremos crear un programa con el cual podamos guardar los títulos y los
autores de diferentes libros sin perder ninguno de ellos. El usuario es el encargado de suministrar la
información de cada libro. Vamos a suponer que el usuario solo podrá ingresar un máximo de 5 libros,
para así tener un tamaño de vector fijo. Veamos entonces como se haría esto:
77
#include "iostream"
int main()
{
char titulos[5];
char autores[5];
cout << "Por favor ingrese la siguiente información de los Libros: \n";
for(int i = 0; i < 5; i++)
{
cout << "\n******* Libro " <> titulos[i];
cout << "Autor: ";
cin >> autores[i];
}
}
Estoy seguro de que a estas alturas comprendes bien qué hace cada una de estas líneas. En caso de
que no comprendas nada de esto, te recomiendo leer nuevamente esta sección, la sección de ciclos o
la sección de entrada y salida de datos.
Hay que considerar que el tipo de dato que estamos usando para los vectores de títulos y autores es
char por lo tanto debes ingresar un único carácter cuando pruebes el algoritmo, pues de lo contrario
el comportamiento será un poco extraño (aunque tiene su explicación). A continuación, haremos este
mismo ejemplo, pero usando cadenas de texto completas (strings) para poder ingresar sin problemas
más de una letra.
Recuerda que, si no tienes clara alguna cosa, detectas algún error, tienes alguna sugerencia o
simplemente tienes algo que comentarme, puedes hacerlo con total tranquilidad.
Ejemplo 1 mejorado
Vamos a solucionar el mismo problema, pero esta vez lo haremos bien. Vamos a utilizar cadenas de
texto completas (string) de modo que al ingresar un título o un autor podamos poner textos
completos:
78
#include "iostream"
#include "string"
int main()
{
string titulos[5];
string autores[5];
for(int i = 0; i < 5; i++)
{
cout << "\n******* Libro " <> titulos[i];
cout << "Autor: ";
cin >> autores[i];
}
}
Muy bien, tal como dije en el ejemplo anterior ahora ya podemos ingresar más de un carácter para el
título y los autores (tal y como debe ser) y nuestro algoritmo funciona aún mejor. Puedes ver que los
únicos cambios necesarios fueron importar la librería string y poner los tipos de datos como string en
vez de char y eso solucionó por completo nuestro problema. Ten en cuenta que en versiones antiguas
de compiladores usar la función cin para leer strings genera un error así que asegurate de usar una
versión reciente o usa entonces la función getline.
Ejemplo perfeccionado
En la versión del ejemplo anterior tenemos un problema un poco delicado, y es que cuando
ingresamos el título del libro o el autor de este con espacios, es decir, más de una palabra
(habitualmente es así) el objeto cin interpreta esto como un fin de línea y no nos solicita el siguiente
valor. Para solucionar esto haremos uso de la función getline (la que mencioné hace un momento)
que nos permite solucionar este tipo de problemas. Vamos a solucionar el mismo problema, pero esta
vez lo haremos bien. Vamos a utilizar cadenas de texto completas (string) de modo que al ingresar un
título o un autor podamos poner textos completos:
79
#include "iostream"
#include "string"
int main()
{
string titulos[5];
string autores[5];
for(int i = 0; i < 5; i++)
{
cout << "\n******* Libro " <> titulos[i]; //No funciona con espacios
getline(cin, titulos[i]);
cout << "Autor: ";
//cin >> autores[i]; //No funciona con espacios
getline(cin, autores[i]);
}
}
Como puedes apreciar, hemos reemplazado las líneas que usaban cin para leer los datos por la función
getline(...) que recibe como primer argumento el flujo de entrada de cin y como segundo argumento
la variable en la que queremos poner el valor.
80
Matrices en C++. Uso, declaración, y sintaxis de las matrices en C++
Las matrices o como algunos las llaman "arreglos multidimensionales" son una estructura de datos
bastante similar a los vectores o arreglos. De hecho, una matriz no es más que una serie de vectores
contenidos uno en el otro (u otros), es decir, una matriz es un vector cuyas posiciones son otros
vectores. Hablemos con más detalle de esto para quedar más claros.
Te recomiendo ver y comprender la sección de arrays o vectores, antes de iniciar con esta parte para
poder dominar el tema de ésta con más facilidad.
Primero, dejemos claro qué es una matriz. En términos generales, una matriz es una estructura
conformada por filas y columnas, idealmente más de dos filas y columnas, de hecho, podemos decir
que, si una "matriz" tiene una única fila o una única columna, entonces estamos hablando de un vector
y no de una matriz como tal.
La intersección de una fila y una columna de la matriz son las casillas y cada una de ellas podrá poseer
información, simple o compleja (ya dependerá de nuestras necesidades).
Ahora, tal como dije antes, un vector posee una única fila (o columna, como lo quieras ver) y de este
modo un grupo de vectores unidos conforman una matriz, es por esto que al comienzo dije que una
matriz es un vector conformado por otra serie de vectores.
Viéndolo desde el punto de vista de la programación, una matriz es un vector cuyas posiciones (de la
cero a la n) son, cada una de ellas, otro vector
Como siempre, la mejor forma de comprender algo es viendo un ejemplo en acción, así que veamos
un buen ejemplo de matrices en C++.
81
Matrices en C++ un buen ejemplo
Muy bien voy a retomar el ejemplo de la sección anterior donde teníamos la necesidad de almacenar
los títulos y los autores de una serie de libros dada.
Tal como mencioné en dicha sección, una solución alternativa al problema, además de correcta y
adecuada; es crear una matriz que almacenará en la primera columna los títulos, y en la segunda
columna los autores; cada fila será entonces la información completa de un libro.
Para solucionar este problema, aprendamos primero algunas normas básicas para poder crear y usar
matrices en C++.
¿Cómo se crea una Matriz en C++?

Declarar una matriz en C++ es muy similar a la de un vector, se deben seguir las mismas normas para
declarar una variable, pero una vez más con un pequeño cambio en la sintaxis. Primero necesitaremos
saber el tipo de los datos que irán al interior de este (números, decimales o cadenas de texto, etc.)
necesitamos también, como siempre, un nombre para la matriz y un tamaño máximo tanto para las
filas como para las columnas. La sintaxis para declarar una matriz en C++ es la siguiente:
tipoDato nombreMatriz[filas][columnas];
Recuerda que, en C++, no es posible crear de una manera sencilla un vector (y por ende una matriz)
capaz de almacenar una cantidad de información indefinida, es necesario ingresar con antelación la
cantidad de datos (filas y columnas) que la matriz tendrá.
Tenemos entonces, como podrás ver, que la sintaxis es casi la misma excepto que hemos añadido un
par de corchetes "[]" más esta vez y al interior de éstos debemos poner el número de filas y columnas
máximas de la matriz, respectivamente. Veamos un ejemplo en el cual pondré la declaración de varias
matrices de diferentes tipos y tamaños en C++.
82
Declaración de una matriz en C++
int myMatriz1[10][5];
float myMatriz2[5][10];
string myMatriz3[15][15];
bool myMatriz4[1000][3];
Veamos rápidamente que representa cada línea del código anterior.
Línea 1
Esta línea contiene la declaración de una matriz llamada myMatriz1 que tendrá 10 filas y 5 columnas
y cada una de las 50 casillas tendrá datos de tipo entero.
Línea 2
y cada una de las 50 casillas tendrá datos de tipo flotante.
Línea 3
(una matriz cuadrada) y cada una de las 225 casillas tendrá datos de tipo string.
Línea 4
Esta línea contiene la declaración de una matriz llamada myMatriz4 que tendrá 1000 filas (sí, leíste
bien) y 3 columnas y cada una de las 3000 casillas (también leíste bien, tres mil casillas) tendrá datos
de tipo booleano.
Ya que está claro cómo se declara una matriz, vamos a inicializarla, es decir darle un valor a cada casilla,
según su tipo de dato.
83
¿Cómo inicializar una matriz en C++?
En cuanto tenemos declarado una matriz, es posible asignarle valores a cada una de sus casillas,
evidentemente estos valores deben coincidir con el tipo de dato que le asignamos a dicha matriz.
Voy a mostrar a continuación formas distintas de inicializar una matriz, todas son válidas, ya es
cuestión de nuestras necesidades y conocimientos determinar cuál es útil y en qué momento. Veamos
entonces:
Forma 1 de declarar una matriz
int myMatriz1[2][2] = {{1,2},{3,4}};
Aquí hemos declarado una matriz de tipo int de dos filas y dos columnas y la hemos inicializado con
diferentes valores. El valor inicial corresponde a la casilla 0,0 (fila cero, columna cero) y tiene el valor
de 1, en la fila cero columna uno tenemos el valor de 2, en la fila uno columna cero el valor de 3 y
finalmente en la fila uno columna uno el valor de 4. Es importante notar que el primer tanto la fila
como la columna comienzan desde cero y no desde uno, por esto la primer casilla corresponde a la
fila y columna cero.
¡Bien! Ya sabemos cómo declarar una matriz en C++, sin embargo, aún no sabemos cómo acceder a
los datos que estas contienen. Veámoslo:
Obtener el valor de una casilla específica

Para acceder al valor de una casilla nuevamente haremos uso de los corchetes, pero esta vez no para
declarar tamaños (porque eso ya lo hicimos) sino para indicar posiciones (fila y columna).
int myMatriz1[2][2] = {{1,2},{1,1}}; //Matriz con 4 elementos
int fila1Casilla1 = myMatriz[1][1]; //Para acceder a la casilla 1,1 se usan dichos indices
int primerNumero = myMatriz[0][0]; //La primer casilla siempre será la de la fila 0 columna 0
Como podemos ver, para acceder a un valor específico conociendo el índice de la casilla, solo basta
con escribir dicho índice entre los corchetes "[][]", recuerda que el índice comienza desde cero, así por
84
lo tanto en una matriz de vector de 2 por 2 (como el ejemplo), el último elemento está en el índice 1
y el primer elemento en el índice 0.
Recorrer una matriz en C++

Para obtener todos los datos que se encuentran al interior de una matriz, debemos acceder a cada
posición y esto se hace fácilmente con dos ciclos for (anidados). La lógica de este procedimiento es la
siguiente, el primer ciclo for comenzará desde cero e ira hasta el número de filas, de modo que la
variable de control que generalmente llamamos "i", será la que va a ir variando entre cero y el tamaño
del array, de esta forma al poner la i al interior de los corchetes, estaremos accediendo al valor de
cada fila y el segundo ciclo irá de cero al número de columnas y normalmente se usa la variable llamada
j para acceder a cada columna, veamos:
En el siguiente código uso una forma sencilla y rápida de obtener la cantidad o número de filas de una
matriz y también cómo obtener el número o cantidad de columnas de una matriz. Ten en cuenta que
esto es importante, pues a veces no tenemos la certeza del tamaño de la matriz.
#include <iostream>
int main()
{
int edades[3][2] = {{1,2},{9,8},{14,21}};
int filas = (sizeof(edades)/sizeof(edades[0]));
int columnas = (sizeof(edades[0])/sizeof(edades[0][0]));
for (int i = 0; i < filas; i++)
{
for (int j = 0; j < columnas; j++)
{
cout<<edades[i][j]<<endl;
}
}
}
Vamos a ver de forma resumida en qué consiste y que hace cada una de estas líneas.
85
Línea 1:
Tenemos en la primera línea la declaración de una matriz que contiene las edades de tres parejas de
personas y asignamos cada uno de los valores.
Líneas 2 y 3:
En estas líneas, tenemos la declaración del número de filas y columnas de la matriz, que serán el límite
del primer y segundo ciclo, respectivamente. Para más detalles de esto, verifica la información sobre
el operador sizeof.
Líneas 4 a 7:
Aquí, tenemos entonces un ciclo for que comienza en cero y termina en el número de filas y luego
tenemos otro ciclo for (anidado) que irá de cero hasta el número de columnas (es importante notar
que la condición usada en ambos ciclos es estrictamente menor "<" y no menor o igual "<="), al interior
del segundo ciclo, es donde accedemos a cada una de las casillas de la matriz usando los corchetes.
Línea 8:
La octava línea es quizá la más vital, aunque sin las demás no tendríamos nada. En esta línea, estamos
accediendo a cada una de las casillas de la matriz, fila por fila y columna por columna. Accedemos a
cada elemento poniendo entre los corchetes la variable i y j, que son las que están cambiando a
medida que los ciclos van "girando", así estaremos accediendo a todos los elementos e
imprimiéndolos por pantalla por medio de cout.
Muy bien, llegó el momento de afianzar nuestros conocimientos viendo un ejemplo. Ahora que
tenemos claro como declarar un vector en C++, como recorrerlo y como acceder a sus datos, vamos a
ver un ejemplo basado en el problema que planteé al inicio de esta sección (el de los libros).
Ejemplo de Matrices en C++

El problema es simple, queremos crear un programa con el cual podamos guardar los títulos y los
autores de diferentes libros sin perder ninguno de ellos. El usuario es el encargado de suministrar la
86
información de cada libro. Vamos a suponer que el usuario solo podrá ingresar un máximo de 5 libros,
para así tener un tamaño de vector fijo. Veamos entonces cómo se haría esto usando matrices:
#include "iostream"
#include "stdio.h"
#include "string"
int main()
{
string libros[5][2];
string titulo, autor;
for(int i = 0; i < 5; i++)
{
cout << "\n******* Libro " << i + 1 << "********:\n";
cout << "Titulo: ";
getline(cin,titulo);
cout << "Autor: ";
getline(cin,autor);
libros[i][0] = titulo;
libros[i][1] = autor;
}
system("pause");
return 0;
}
Notar que, en el código anterior, debido a que tenemos la completa certeza de sólo usar dos columnas,
no es necesario usar otro ciclo for (de hecho, eso complicaría todo) basta con poner de manera
explícita que el valor del título va en la columna cero y el del autor en la columna uno.
En este caso tenemos una matriz con una cantidad de fila que dependen de la cantidad de libros y dos
columnas. Para el ejemplo, decidimos tener 5 posibles libros. Donde cada uno tendrá su respectivo
título y autor. Así entonces, en la columna cero (0) iría el título y en la columna uno (1) el autor.
87
Por cada libro que queremos agregar, debemos especificar su título y su autor. Por ello, la segunda
posición que se especifica en esta matriz de libros siempre será 0 o 1, según sea el caso. Mientras que
en la primera posición usamos la variable i del ciclo, que va a variar de 0 a 4, para un total de cinco
libros.
Recuerda que, si no comprendes alguna cosa, detectas algún error, tienes alguna sugerencia o
simplemente tienes algo que comentarme, puedes hacerlo con total tranquilidad.
Los punteros y elementos dinámicos en C++ con ejemplos y ejercicios resueltos.

Los punteros en C++ (o apuntadores) son quizá uno de los temas que más confusión causan al
momento de aprender a programar en C++, sin embargo, verás que no es para tanto y que todo
depende de dos elementos: el signo & (ampersand) y el * (asterisco) que los explicaré en breve.
Durante este texto verás entonces que no es para nada difícil hacer y usar punteros y que además son
de gran ayuda al momento de necesitar valores y estructuras dinámicas, por ejemplo, para crear un
array dinámico, con dinámico me refiero a que su tamaño puede ser establecido en tiempo de
ejecución y lo mismo se puede hacer con las matrices (que en realidad son un array multidimensional).
Muy bien para comenzar veamos un pequeño ejemplo y luego su correspondiente explicación, una
excelente forma de aprender. No te preocupes de entender todo con este primer ejemplo, pues
durante el resto del texto explicaré cada componente, su sintaxis y el final, cómo aprovechar dichas
funcionalidades para nuestro beneficio junto con algún ejercicio.
Ejemplo de punteros
int variable; //Creamos un entero

int * apuntador = &variable; //Creamos un apuntador a la posición en memoria de "variable"
*apuntador = 20; //Le asignamos un valor a esa posición de memoria.
delete [] apuntador; //Después de operar con punteros es necesario liberar la memoria.

puntero = NULL;
Muy bien, ya hemos creado y usado nuestro primer puntero ¿Notaste el uso del asterisco y del
ampersand? espero que sí y además de eso hay otros detalles que debemos considerar, veamos:
88
Detalles al crear y usar punteros en C++
 El tipo de dato del apuntador debe coincidir con el de la variable cuya posición en memoria
apuntan. En el ejemplo vemos que tanto variable como apuntador son enteros.
 Siempre que queremos usar el apuntador debemos anteponer el asterisco (*) para indicar que
usaremos el valor en la posición de memoria apuntada.
 De no usar el asterisco el comportamiento sería impredecible. Estaremos haciendo uso de la
dirección de memoria más no del valor almacenado en ésta.
 Después de usar un puntero, especialmente si trabajamos con arreglos o matrices, es MUY
recomendable liberar la memoria utilizada con la función delete (tal como en el ejemplo)
 Un puntero o apuntador puede ser de cualquier tipo de dato, inclusive los podemos usar con
tipos complejos.
Ya que sabemos algunos trucos y detalles sobre los apuntadores en C++, vamos a definir formalmente
la utilidad del operador & y del asterisco.
Los punteros y el ampersand

El ampersand es un operador de C++ y es comúnmente utilizado para los punteros. Este operador nos
permite obtener la dirección de memoria de una variable cualquiera y es justo esto (la dirección en
memoria) lo que utilizan los punteros para referenciar valores.
Los apuntadores y el asterisco

El asterisco es, por decirlo de alguna forma, el operador por excelencia de los punteros. SU utilidad
radica en que, si el valor de dicho apuntador corresponde a una dirección de memoria, el asterisco
nos permite resolverla y acceder al valor almacenado allí. Viéndolo desde otro enfoque, un apuntador
es únicamente una dirección de memoria (un número) y el asterisco es el que hace la magia de obtener
el valor referenciado por dicha dirección.
Veamos otro ejemplo con cada elemento detallado paso a paso.
89
Ejemplo de apuntadores
char *apuntador = NULL; //Declaramos un puntero

//Es recomendable inicializar un puntero en null, para detectar errores fácilmente
char letra; //Declaramos una variable primitiva
apuntador = &letra; //Asignamos al apuntador la dirección de memoria de la variable primitiva
*apuntador = 'x'; //Modificamos la variable a través del apuntador
cout << letra; //Muestra x por pantalla
En este ejemplo vemos que podemos usar cualquier tipo de dato, que un puntero se puede inicializar
independientemente y luego se le puede asignar su referencia correspondiente. Nótese que al asignar
(línea 6) no utilizamos el asterisco, pues estamos definiendo la dirección de memoria y no el valor en
dicha dirección (recuerda que el * resuelve la dirección de memoria y no es lo que requerimos en esa
línea).
Ahora que hemos visto los ejemplos y tenemos claro el uso del ampersand y el asterisco podemos
entonces realizar algunos ejercicios interesantes.
Ejercicios con punteros en C++

Parámetros por referencia.
Usualmente al enviar un parámetro a una función todo lo que se haga con dicho parámetro allí adentro
NO tiene efecto por fuera. Por ejemplo, si a una función se le envía una variable cuyo valor es diez y
al interior de la función le sumamos un cinco, después de la ejecución de la función el valor de la
variable seguirá siendo diez en vez de quince. Lo que pasó al interior de la función se quedó allí. Para
solucionar esto, si queremos que el valor cambie definitivamente, usamos punteros para pasar no el
valor del parámetro sino una referencia a éste (paso por referencia). Veamos:
90
#include "iostream"
#include "stdio.h"
int funcion(int valor)

{
valor = valor + 10; //Se le suma 10
return valor;
}
int funcionPunteros(int* valor)

{
*valor = *valor + 10; //Se le suma 10 a la posición en memoria
return *valor;
}
int main()
{
int numero = 10;
cout << "Antes de funcion " << numero << "\n"; //10
funcion(numero); //Se pasa por valor
cout << "Despues de funcion " << numero << "\n"; //10
cout << "Antes de funcionPunteros " << numero << "\n"; //10
funcionPunteros(&numero); //Se envía la dirección de memoria y la función resuelve la

referencia
cout << "Despues de funcionPunteros " << numero << "\n"; //20 (10+10)
system("pause");
return 0;
}
Como podrás comprobar si ejecutas el código del ejercicio al llamar a "funcion" sólo enviamos el valor
y por ende éste no es modificado por fuera de la función, con "funcionPunteros" estamos manipulando
la posición en memoria del parámetro recibido (por eso usamos el *) y por ende al ejecutarla el valor
91
de la variable se modifica. De ese modo ya hicimos el primer ejercicio con punteros en C++ y ya
comprendemos el paso por referencia.
Array dinámico
Como se mencionó al comienzo, por medio de apuntadores podemos crear arreglos o vectores
dinámicos, es decir, un array al cual se le define su tamaño o capacidad durante la ejecución del código
y no antes, lo cual nos permite definirle el tamaño deseado por el usuario.
Para este ejercicio retomaré el ejemplo del artículo de arreglos o vectores: Queremos crear un
programa con el cual podamos guardar los títulos y los autores de diferentes libros sin perder ninguno
de ellos. El usuario es el encargado de suministrar la información de cada libro. En esta ocasión ya
sabemos usar punteros, así que será también el usuario quien nos diga cuántos libros desea ingresar,
ya no necesitamos suponer que sólo ingresará 5 libros. Veamos:
92
#include "iostream"
#include "stdio.h"
#include "string"
int main()
{
string* titulos = NULL; //Se inicializa el puntero (inicia en null)
string* autores = NULL; //Se inicializa el puntero (inicia en null)
int tamanio ; //Se inicializa la variable
cout << "Cuantos libros desea ingresar?";
string entrada;
getline(cin, entrada); //Se asigna el valor ingresado
tamanio = stoi(entrada); //Se transforma la entrada en número
titulos = new string[tamanio]; //Declaramos un arreglo del tamaño ingresado para los titulos
autores = new string[tamanio]; //Declaramos un arreglo del tamaño ingresado para los autores
for(int i = 0; i < tamanio; i++)
{
cout << "\n******* Libro " <> titulos[i]; //No funciona con espacios
getline(cin, titulos[i]);
cout << "Autor: ";
//cin >> autores[i]; //No funciona con espacios
getline(cin, autores[i]);
}
//Liberamos la memoria de ambos punteros

delete [] titulos;
delete [] autores;
titulos = NULL;
autores = NULL;
system("pause");
return 0;
} 93
Así entonces tuvimos dos punteros, uno para todos los autores y otro para todos los títulos. Haciendo
uso de ellos pudimos definir la cantidad de libros a ingresar por medio del usuario, es decir lo hicimos
de manera dinámica, en tiempo de ejecución.
Matrices dinámicas
Así como lo hicimos con los array, también podemos tener matrices dinámicas y definir su tamaño,
número de filas o número de columnas (o las dos) según sea necesario.
Para esto tomaré el mismo ejemplo de los libros, pero usando una matriz, en vez de dos vectores, tal
y como se solucionó en la sección de matrices veamos:
94
#include "iostream"
#include "stdio.h"
#include "string"
int main()
{
int cols = 2; //El número de columnas es fijo (sólo título y autor)
string** libros; //Si inicializa la matriz (punteros de punteros)
int tamanio ; //Se inicializa la variable
cout << "Cuantos libros desea ingresar?";

string entrada;
getline(cin, entrada); //Se asigna el valor ingresado
tamanio = stoi(entrada); //Se transforma la entrada en número
libros = new string*[tamanio];//Se asigna el número de filas según el usuario
string titulo ,autor;
for(int i = 0; i < tamanio; i++)

{
libros[i] = new string[cols]; //Cada fila contendrá dos columnas
//Notar que cols pudo haber sido ingresada por el usuario también
cout << "\n******* Libro " << i + 1 << "********:\n";

cout << "Titulo: ";
getline(cin,titulo);
cout << "Autor: ";
getline(cin,autor);
libros[i][0] = titulo;
libros[i][1] = autor;
}
//Para liberar la memoria debemos recorrer fila por fila primero.

for (int i = 0; i < tamanio; ++i)
{
delete [] libros[i]; //Cada fila de libros es otro array de punteros
//Por eso son punteros a punteros
}
//Luego de limpiar las columnas, quitamos la fila única que quedó

delete [] libros;
system("pause");
return 0; 95
}
Este ejercicio es el perfecto para aclarar dudas o darse cuenta si realmente comprendes el concepto
de apuntadores y su aplicación para arrays dinámicos. Debido a que la cantidad de columnas es fija,
no se lo pedimos al usuario, simplemente lo declaramos con valor dos. Luego tenemos el puntero,
pero no es un puntero cualquiera, al ser una matriz, será un puntero que tendrá otros punteros
adentro, por eso se usa doble asterisco, luego se obtiene el tamaño del usuario (cantidad de libros) y
al momento de inicializar la fila estamos indicando que es un arreglo de punteros, por eso se usa el *
en la línea 23. Luego al interior del ciclo, cuando estamos llenando la matriz, debemos indicar que cada
fila estará compuesta por un array de punteros de tamaño dos (dos columnas) y así construimos
nuestra matriz dinámica.
Debes notar también que la liberación de la memoria es un poco más trabajosa, pues debemos ir fila
por fila liberando la memoria de las columnas creadas y luego liberar la fila completa. Ahí podrás notar
la diferencia en eficiencia y uso de memoria al usar arreglos o usar matrices.
Muy bien, es todo en esta función. Espero haber sido muy claro y que los ejemplos y ejercicios te
hayan servido de mucho. En este momento ya debes saber qué es y cómo hacer un puntero en C++,
para qué sirve el ampersand y el asterisco cuando estamos hablando de apuntadores en C++ y cómo
crear arrays dinámicos y matrices usándolos.
96
Capítulo VIII. Bibliotecas o librerías en C++. Declaración y uso de
librerías. Include en C++
Junto con los compiladores de C y C++, se incluyen ciertos archivos llamados bibliotecas más
comúnmente librerías. Las bibliotecas contienen el código objeto de muchos programas que permiten
hacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar números, realizar
funciones matemáticas, etc.
Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay bibliotecas de entrada y salida,
matemáticas, de manejo de memoria, de manejo de textos y como imaginarás existen muchísimas
librerías disponibles y todas con una función específica.
Existe una discusión sobre el nombre de estos archivos. Muchas personas consideran que el nombre
adecuado es archivos de biblioteca, y están en lo correcto. Sin embargo, la mayoría llamamos a estos
archivos librerías, y también me incluyo entre estos. El error proviene del nombre en inglés, que es
library. Este término se traduce como biblioteca, y no como librería. De este modo a lo largo de esta
sección las llamaremos de cualquiera de las dos formas, para estar más claros.
Hay un conjunto de bibliotecas (o librerías) muy especiales, que se incluyen con todos los compiladores
de C y de C++. Son las librerías (o bibliotecas) ANSI o estándar. También hay librerías que no son parte
del estándar, pero en esta sección sólo usaremos algunas bibliotecas (o librerías) ANSI.
¿Qué son exactamente las librerías?

En C++, se conoce como librerías (o bibliotecas) a cierto tipo de archivos que podemos importar o
incluir en nuestro programa. Estos archivos contienen las especificaciones de diferentes
funcionalidades ya construidas y utilizables que podremos agregar a nuestro programa, como por
ejemplo leer del teclado o mostrar algo por pantalla entre muchas otras más.
Al poder incluir estas librerías con definiciones de diferentes funcionalidades podremos ahorrarnos
gran cantidad de cosas, imaginemos por ejemplo que cada vez que necesitemos leer por teclado,
97
debamos entonces crear una función que lo haga (algo realmente complejo), al poder contar con las
librerías en C++, podremos hacer uso de una gran variedad de funciones que nos facilitarán la vida y
aumentarán la modularidad de nuestros códigos.
Las librerías no son únicamente archivos externos creados por otros, también es posible crear nuestras
propias librerías y utilizarlas en nuestros programas. Las librerías pueden tener varias extensiones
diferentes, las más comunes son: .lib, .bpl, .a, .dll, .h y algunas más ya no tan comunes.
Las librearías son archivos (no siempre externos) que nos permiten llevar a cabo diferentes tareas sin
necesidad de preocuparnos por cómo se hacen sino simplemente entender cómo usarlas. Las
librearías en C++ permiten hacer nuestros programas más modulares y reutilizables, facilitando
además crear programas con funcionalidades bastante complejas en unas pocas líneas de código.
Sintaxis para declarar Librerías en C++

La declaración de librerías, tanto en C como en C++, se debe hacer al principio de todo nuestro código,
antes de la declaración de cualquier función o línea de código, debemos indicarle al compilador que
librerías usar, para el saber que términos estarán correctos en la escritura de nuestro código y cuáles
no. La sintaxis es la siguiente: #include <nombre de la librería> o alternativamente #include "nombre
de la librería". Cualquiera de las 2 formas es válida en C++ (no estoy seguro si en C sea válido), ten en
cuenta que siempre el nombre de la librería debe ir entre " y " o entre < y >. En tu código puedes
declarar todas las librerías que quieras, aunque en realidad no tienen sentido declarar una librería que
no vas a usar en tu programa, sin embargo, no existe límite para esto.
Librerías Estándar de C++ (Standar Template Library o STL)

A continuación, pondré algunas de las librerías de uso más común de C++ y que forman parte de las
librerías estándar de este lenguaje.
 fstream: Flujos hacia/desde archivos. Permite la manipulación de archivos desde el programar,
tanto leer como escribir en ellos.
98
 iosfwd: Contiene declaraciones adelantadas de todas las plantillas de flujos y sus typedefs
estándar. Por ejemplo, ostream.
 iostream: Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e
importante (aunque no indispensable).
 La biblioteca list: Parte de la STL relativa a contenedores tipo list; listas doblemente enlazadas
 math: Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación
de funciones matemáticas.
 memory: Utilidades relativas a la gestión de memoria, incluyendo asignadores y punteros

inteligentes (auto_ptr).
"auto_ptr" es una clase que conforma la librería memory y permite un fácil manejo de punteros
y su destrucción automaticamente.
 Biblioteca new: Manejo de memoria dinámica
 numeric: Parte de la librería numérica de la STL relativa a operaciones numéricas.
 ostream: Algoritmos estándar para los flujos de salida.
 queue: Parte de la STL relativa a contenedores tipo queue (colas de objetos).
 Librería stdio: Contiene los prototipos de las funciones, macros, y tipos para manipular datos
de entrada y salida.
99
 Librería stdlib: Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso
general.
 string: Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas
alfanuméricas para albergar cadenas de objetos. Muy útil para el fácil uso de las cadenas de
caracteres, pues elimina muchas d elas dificultades que generan los char
 typeinfo: Mecanismo de identificación de tipos en tiempo de ejecución
 vector: Parte de la STL relativa a los contenedores tipo vector; una generalización de las
matrices unidimensionales C/C++
 forward_list: Esta librería es útil para implementar con gran facilidad listas enlazadas simples.
 List: Permite implementar listas doblemente enlzadas (listas enlazadas dobles) facilmente.
 Iterator: Proporciona un conjunto de clases para iterar elementos.
 Regex: Proporciona fácil acceso al uso de expresiones regulares para la comparación de

patrones.
 Thread: Útil para trabajar programación multihilos y crear múltiples hilos en nuestra
aplicación.
¿Cómo declarar una librería en C++?

Veamos a continuación como se haría la declaración de unas cuantas librerías conocidas, recuerda que
se pueden declarar todas las librerías necesarias y siempre debe hacerse al comienzo del código
fuente.
100
#include "iostream"
#include "string"
#include <math.h>
#include <conio.h>
Con esto debió quedar claro, como declarar librerías C++ al interior de un código fuente. Lo único
adicional, es la línea que dice using namespace std; esta línea nos ayuda a declarar un espacio de
nombre que evita tener que usarlo cada que accedemos a alguna función específica de una librería.
Teniendo este namespace declarado podemos llamar por ejemplo el comando cout >>, que pertenece
a la librería iostream, sin embargo sin este namespace sería std::cout >>, imagina tener que hacer esto
cada vez que uses algún comando o función de las librerías, sería bastante tedioso.
Acerca del namespace std

Todas las librerías estándar de C++ contienen una declaración del espacio de nombre std, es decir que
todas las librerías que hacen parte del estándar de C++ colocan entidades dentro de este espacio de
nombre.
Por esta razón cuando declaramos el uso del espacio de nombre std por medio de "using namespace
std;", podemos evitar estar escribiendo std::cout o std::cin, etc en nuestro código.
El espacio de nombre std como tal no es una librería sino simplemente un namespace, por esta razón
no reemplaza la declaración de las librerías del código, simplemente facilita la escritura de éste al
momento de usar las entidades de las librerías estándar. Sin embargo si vamos a hacer uso de una o
varias librerías estándar de C++ es recomendable que declaremos el namespace std, para no tener que
estar constantemente escribiendo cosas similares a las que puse hace unas líneas como std::cin o
similares, dado que únicamente se puede acceder a la entidades de las librerías estándar por medio
del espacio nombre std.
Muy bien, ahora veamos algunos ejemplos simples del uso de librerías o bibliotecas en C++.
101
Ejemplo 1 de librerías en C++
En el siguiente ejemplo veremos el uso de la librería stdlib.h que posee una gran variedad de
funcionalidades, para este ejemplo usaremos la función rand que nos permite generar un número
aleatorio.
#include <stdlib.h>
#include <iostream>
int main ()
{
cout << ("Se va a generar un numero aleatorio ....\n");
cout << ("El numero generado es : ");
cout << rand(); //Se genera el número con rand y se muestra
en pantalla
return 0;
}
En el anterior código hemos hecho uso de dos librerías: iostream y stdlib. La librería o biblioteca
iostream, nos permitirá hacer uso del cin y el cout para obtener o imprimir valores por pantalla,
respectivamente mientras stdlib nos dará acceso a la función rand que generará por nosotros un
número cualquiera.
Ejemplo 2 de librerías en C++

En el siguiente ejemplo veremos el uso de la librería string.h que nos permite básicamente crear y
manipular muy fácilmente cadenas de caracteres.
102
#include <string.h>
#include <iostream>
int main ()
{
cout << ("Hola! Por favor ingrese su nombre ....\n");
string cadena = "Hola "; //Se le da un valor inicial al string
string nombre; //Esta cadena contendrá el nombre

cin >> nombre; //Se lee el nombre
cadena = cadena + nombre; //Se juntan el saludo con el nombre usando "+"
cout << (cadena); //Se muestra el resultado final.
return 0;
}
Aquí hemos mostrado un mensaje solicitando el nombre al usuario y luego usando string, hemos
creado un saludo que incluya el nombre del usuario. "Hola Juan".
Ejemplo 3 para bibliotecas en C++

En este ejemplo usaremos la biblioteca vector, iterator y list, para crear una lista doblemente enlazada,
agregar algunos elementos en ella (incluido un vector) y recorrerla.
103
#include <iostream>
#include <list>
#include <vector>
int main ()
{
list<int> miLista; //Creamos
list<int>::iterator it;
for (int i=10; i<=50; i = i+10)

{
miLista.push_back(i);
}
//Se agrega un 10 20 30 40 50 a la lista
it = miLista.begin(); //Se estabelce el iterador al comienzo de la lista

it++; //Movemos el iterador una posición (ahora estamos en 20)
//Se inserta un 11 en la posición del 10 11 20 30 40 50

miLista.insert (it,11);
miLista.insert (it,3,18);
//En la actual posición del 20 insertamos un 18 tres veces
//10 11 18 18 18 20 30 40 50
//Creamos un vector que poseerá dos elementos con valor de 19

vector<int> myvector (2,19);
//Insertamos ese vector en la lista, enviando los iteradores del propio vector
miLista.insert (it,myvector.begin(),myvector.end());
//10 11 18 18 18 19 19 20 30 40 50
cout << "Mi lista contiene lo siguiente:";
for (it=miLista.begin(); it!=miLista.end(); it++)

{
cout << ' ' << *it; //Se muestra el valor al cual está apuntando el iterador
}
return 0;
} 104
El resultado final de la ejecución de este código debería mostrar por pantalla "Mi lista contiene lo
siguiente: 10 11 18 18 18 19 19 20 30 40 50" que es el resultado final de la inserción.
¡¡¡Bueno!!! Es todo lo que necesitas saber sobre librerías, al menos en la lista que te he puesto, están
las que vamos a usar para ejemplos y ejercicios y algunas otras de más.
Capítulo IX. Funciones, métodos y procedimientos en C++. Desde

cero y paso a paso
Las funciones son una herramienta indispensable para el programador, tanto las funciones creadas
por él mismo como las que le son proporcionadas por otras librerías, cualquiera que sea el caso, las
funciones permiten automatizar tareas repetitivas, encapsular el código que utilizamos, e incluso
mejorar la seguridad, confiabilidad y estabilidad de nuestros programas. Dominar el uso de funciones
es de gran importancia, permiten modularizar nuestro código, separarlo según las tareas que
requerimos, por ejemplo, una función para abrir, otra para cerrar, otra para actualizar, etc.
básicamente una función en nuestro código debe contener la implementación de una utilidad de
nuestra aplicación, es decir que por cada utilidad básica (abrir, cerrar, cargar, mover, etc.) sería
adecuado tener al menos una función asociada a ésta.
Antes de comenzar a hablar acerca de la creación de funciones y su uso en C++, debo hablar de tres
conceptos relativamente diferentes.
¿Funciones, métodos o procedimientos?

En el mundo de la programación, muchos acostumbramos hablar indistintamente de estos tres
términos sin embargo poseen deferencias fundamentales.
Funciones:
Las funciones son un conjunto de procedimiento encapsulados en un bloque, usualmente reciben
parámetros, cuyos valores utilizan para efectuar operaciones y adicionalmente retornan un valor. Esta
definición proviene de la definición de función matemática la cual posee un dominio y un rango, es
105
decir un conjunto de valores que puede tomar y un conjunto de valores que puede retornar luego de
cualquier operación.
Métodos:
Los métodos y las funciones son funcionalmente idénticos, pero su diferencia radica en el contexto en
el que existen. Un método también puede recibir valores, efectuar operaciones con estos y retornar
valores, sin embargo, en método está asociado a un objeto, básicamente un método es una función
que pertenece a un objeto o clase, mientras que una función existe por sí sola, sin necesidad de un
objeto para ser usada.
Procedimientos:
Los procedimientos son básicamente un conjunto de instrucciones que se ejecutan sin retornar ningún
valor, hay quienes dicen que un procedimiento no recibe valores o argumentos, sin embargo en la
definición no hay nada que se lo impida. En el contexto de C++ un procedimiento es básicamente una
función void que no nos obliga a utilizar una sentencia return.
Declarando funciones en C++

La sintaxis para declarar una función es muy simple, veamos:
tipo nombreFuncion([tipo nombreArgumento,[tipo nombreArgumento]...])

{
/*
* Bloque de instrucciones
*/
return valor;
}
Recordemos que una función siempre retorna algo, por lo tanto, es obligatorio declararle un tipo (el
primer componente de la sintaxis anterior), luego debemos darle un nombre a dicha función, para
poder identificarla y llamarla durante la ejecución, después al interior de paréntesis, podemos poner
los argumentos o parámetros. Luego de la definición de la "firma" de la función, se define su
funcionamiento entre llaves; todo lo que esté dentro de las llaves es parte del cuerpo de la función y
éste se ejecuta hasta llegar a la instrucción return.
106
Acerca de los argumentos o parámetros
Hay algunos detalles respecto a los argumentos de una función, veamos:
1. Una función o procedimiento pueden tener una cantidad cualquier de parámetros, es decir
pueden tener cero, uno, tres, diez, cien o más parámetros. Aunque habitualmente no suelen
tener más de 4 o 5.
2. Si una función tiene más de un parámetro cada uno de ellos debe ir separado por una coma.
3. Los argumentos de una función también tienen un tipo y un nombre que los identifica. El tipo
del argumento puede ser cualquiera y no tiene relación con el tipo de la función.
Consejos acerca de return

Debes tener en cuenta dos cosas importantes con la sentencia return:
1. Cualquier instrucción que se encuentre después de la ejecución de return NO será ejecutada.
Es común encontrar funciones con múltiples sentencias return al interior de condicionales,
pero una vez que el código ejecuta una sentencia return lo que haya de allí hacia abajo no se
ejecutará.
2. El tipo del valor que se retorna en una función debe coincidir con el del tipo declarado a la
función, es decir si se declara int, el valor retornado debe ser un número entero.
Ejemplos de funciones
Veamos algunos ejemplos prácticos de funciones en C++.
Ejemplo 1:
int funcionEntera() //Función sin parámetros

{
int suma = 5+5;
return suma; //Acá termina la ejecución de la función
return 5+5; //Este return nunca se ejecutará
//Intenta intercambiar la línea 3 con la 5
int x = 10; //Esta línea nunca se ejecutará
}
107
Como puedes ver es un ejemplo sencillo, si ejecutas esto, la función te retornará el valor de suma que
es 10 (5+5). Las líneas posteriores no se ejecutarán nunca, aunque no generan error alguno, no tienen
utilidad. Puedes notar que para este caso es lo mismo haber escrito return suma que escribir return
5+5. Ambas líneas funcionan equivalentemente.
Ejemplo 2:
char funcionChar(int n) //Función con un parámetro

{
if(n == 0) //Usamos el parámetro en la función
{
return 'a'; //Si n es cero retorna a
//Notar que de aquí para abajo no se ejecuta nada más
}
return 'x'; //Este return sólo se ejecuta cuando n NO es cero
}
Aquí hicimos uso se múltiples sentencias return y aprovechamos la característica de que al ser
ejecutadas finalizan inmediatamente la ejecución de la parte restante de la función. De este modo
podemos asegurar que la función retornará 'a' únicamente cuando el valor del parámetro n sea cero
y retornará un 'x' cuando dicho valor no sea cero.
Ejemplo 3:
bool funcionBool(int n, string mensaje) //Función con dos parámetros

{
if(n == 0) //Usamos el parámetro en la función
{
cout << mensaje; //Mostramos el mensaje
return 1; //Si n es cero retorna 1
return true; //Equivalente
}
return 0; //Este return sólo se ejecuta cuando n NO es cero
return false; //Equivalente
}
108
Aquí ya tenemos una función que recibe dos parámetros, uno de ellos es usado en el condicional y el
otro para mostrar su valor por pantalla con cout, esta vez retornamos valores booleanos 0 y 1, pudo
ser true o false también.
Hablemos un poco de los procedimientos

Los procedimientos son similares a las funciones, aunque más resumidos. Debido a que los
procedimientos no retornan valores, no hacen uso de la sentencia return para devolver valores y no
tienen tipo específico, solo void. Veamos un ejemplo:
Ejemplo de procedimientos
void procedimiento(int n, string nombre)

{
if(n == 0)
{
cout << "hola" << nombre;
return;
}
cout << "adios" << nombre;
}
De este ejemplo podemos ver que ya no se usa un tipo, sino que se pone void, indicando que no
retorna valores, también podemos ver que un procedimiento también puede recibir parámetros o
argumentos.
Los procedimientos también pueden usar la sentencia return, pero no con un valor. En los
procedimientos el return sólo se utiliza para finalizar allí la ejecución de la función.
Invocando funciones y procedimientos en C++

Ya hemos visto cómo se crean y cómo se ejecutan las funciones en C++, ahora veamos cómo hacemos
uso de ellas.
nombreFuncion([valor,[valor]...]);
109
Como puedes notar es bastante sencillo invocar o llamar funciones en C++ (de hecho, en cualquier
lenguaje actual), sólo necesitas el nombre de la función y enviarle el valor de los parámetros. Hay que
hacer algunas salvedades respecto a esto.
Detalles para invocar funciones

 El nombre de la función debe coincidir exactamente al momento de invocarla.
 El orden de los parámetros y el tipo debe coincidir. Hay que ser cuidadosos al momento de
enviar los parámetros, debemos hacerlo en el mismo orden en el que fueron declarados y
deben ser del mismo tipo (número, texto u otros).
 Cada parámetro enviado también va separado por comas.
 Si una función no recibe parámetros, simplemente no ponemos nada al interior de los
paréntesis, pero SIEMPRE debemos poner los paréntesis.
 Invocar una función sigue siendo una sentencia habitual de C++, así que ésta debe finalizar con
';' como siempre.
 El valor retornado por una función puede ser asignado a una variable del mismo tipo.
 Una función puede llamar a otra dentro de sí misma o incluso puede ser enviada como
parámetro a otra.
Ejemplos de uso de funciones

En el siguiente código vamos a hacer un llamado a algunas de las funciones y al procedimiento, que
declaramos anteriormente.
En el siguiente código podemos ver cómo todas las funciones han sido invocadas al interior de la
función main (la función principal), esto nos demuestra que podemos hacer uso de funciones al
interior de otras. También vemos cómo se asigna el valor retornado por la función a la variable
'respuesta' y finalmente, antes del return, vemos cómo hemos usado el valor retornado por
'funcionBool' como parámetro del procedimiento.
110
int main()
{
funcionEntera(); //Llamando a una función sin argumentos
bool respuesta = funcionBool(1, "hola"); //Asignando el valor retornado a una variable
procedimiento(0, "Juan");//Invocando el procedimiento
//Usando una función como parámetro

procedimiento(funcionBool(1, "hola"), "Juan");
return 0;
}
111

Curso de C++

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curso de C++

Încărcat de

Drepturi de autor:

Formate disponibile

Tabla de contenido

Capítulo I. Introducción. ................................................................................................................ 4

/* "Hola mundo" escrito en C */

// "Hola mundo" escrito en C++

// #include "iostream" esta opción también es correcta

using namespace std;

cout << "Hola mundo";

Instalación y configuración de un entorno de desarrollo IDE) para C++

Visual C++ (Visual Studio):

Creación de un proyecto en el IDE Visual C++. Proyectos en C++

/* "Hola mundo" escrito en C++ */

Comentar código en C++. Documenta tus aplicaciones por medio de comentarios en

Veamos algunos ejemplos

Intenta algo como lo siguiente y me dices que pasa jeje:

int main(){ int numero;numero = 5 + 5;return 0; }

Tipos nativos o primitivos de C++

Tipos de datos primitivos en C++. Declaración y asignación a variables

¿Cómo se declara una variable en C++?

En el momento de asignar un nombre a una variable se deben seguir algunas normas:

Algunos ejemplos de nombres correctos:

Algunos ejemplos de nombres incorrectos:

Variables y constantes en C++. Asignación de valores, uso de #define y const en C++

int num; //Declaramos el entero en una línea

int num2 = 8; //Asignacion y declaracion al tiempo

float numero; //Un numero decimal

bool valor = false; //Variable booleana

res = res*2; //Duplicamos el valor de res 16.5*2 = 33

Uso de #define para declarar constantes en C++

#define PI 3.1416; //Definimos una constante llamada PI

#define PI 3.1416; //Definimos una constante llamada PI

Ejemplo de uso de const en C++ para declarar constantes

using namespace std;

const float PI = 3.1416; //Definimos una constante llamada PI

cout << "Mostrando el valor de PI: " << PI << endl;

PI = 2; //Esto generará un error pues PI es de solo lectura (constante)

¿Cuándo usar una variable o una constante en C++?

Capítulo IV. Entrada y salida de datos en C++. Uso de cin y cout

Salida de texto por pantalla en C++

Veamos algunos ejemplos para mostrar texto por pantalla en C++:

using namespace std;

Ejemplo 2 de impresión de texto por pantalla en C++.

using namespace std;

//Se concatenan y muestran los valores por pantalla con cout<<

Entrada o lectura de datos en C++

using namespace std;

string nombre;//En esta variable estará almacenado el nombre ingresado.

using namespace std;

Condicional if en C++. Declaración, uso y sintaxis del if en C++

¿Cómo funciona un Condicional If?

if(condición a evaluar) //Por ejemplo X <= 10

Ejemplos de Condicional If-else en C++

Ejemplo 1: Verificación de valores en C++

El código funcional completo sería el siguiente:

using namespace std;

¿Cómo funciona un Condicional If-Else?

Sintaxis del Condicional If-Else en C++:

Ejemplos de Condicional If-else en C++

string password = "";

El código funcional completo sería el siguiente:

using namespace std;

Condicional switch en C++. Declaración uso y sintaxis de switch en C++

Sintaxis del Condicional Switch en C++:

switch(opción) //donde opción es la variable a comparar

Ejemplos de Condicional Switch en C++

res = res2; //Duplicamos el valor de res 16.52 = 33