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 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 Multilínea: Van cerrados entre "/*" y "*/". Estos comentarios son

similares a los anteriores, pero deben tener un comienzo y un fina, 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, m se convertirán en comentarios, de
manera que debemos cerrarlo en el punto donde dicho comentarios termina

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*/

Estructura básica de un programa en C++.
Comenzando a programar en C++
Me parece que la mejor forma de no perder el interés de los lectores 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.

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á 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 hablaré de esto). En ocasiones
(dependiendo del compilador), se puede poner como void (vacía) y por lo tanto no
se puede usar un return, aunque no es recomendable, simplemente por claridad y
evitar errores con compiladores más tradicionales.

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 número, 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 mencionen 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 número 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 (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 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 al línea 1 (ojo! cuando se declare una función no se use
punto y coma, en la línea 1 simplemente se está implementando la función main).
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, 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 número, que ahora tendrá el valor de la
operación matemática 5 + 5 es decir, la variable número 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 número = 5 + 5; es válido, pero escribir número == 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 (ósea 10) a la variable
"numero" mientras que la segunda verifica si el valor de la variable "numero" es
igual o no a 10.

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 número 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.

Muy bien, ya que conoces la estructura básica de una aplicación en C++, y

algunos tipos primitivos de datos (profundicé un poco al respecto) vamos a ir
mucho mas profundo, vamos a conocer otras nuevas estructuras y elementos
usados comúnmente.

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++.

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 poseen los tipos primitivos, pero no te preocupes por esto, en
la sección de librerías o bibliotecas de C++ hablo un poco de cómo se usan y los
tipos de dato que proporcionan. Luego, en la sección de objetos y clases, hablaré
con más detalle al respecto.

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:

 1. El nombre de una variable nunca debe comenzar con un numero.

 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. Las palabras son las siguientes:

Palabras reservadas de C++

auto const double float

int short struct unsigned

break continue else for

long signed switch void

case default enum goto

registe sizeof typede volatile

r f

char do extern if

return static union while

Algunos ejemplos de nombres correctos:

 FechaNacimiento
 variable12
 nombre_variable
 contador
 ACUMULADOR

Algunos ejemplos de nombres incorrectos:

  12variable
 float
 register
 variable nueva
 nueva-variable

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
-[Link] y [Link]. Este tipo de dato es usado para números
enteros (sin cifras decimales). A continuación, alguna 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
[Link].
 long long int: Tiene un tamaño de 64 bits y un rango entre
-[Link].808 y [Link].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 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 duranet ejecución los datos que usamos y
normalmente estarán disponibles a lo 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>

using namespace std;

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++.

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 despues 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

#include <iostream>

using namespace std;

#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>

using namespace std;

#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 despues 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:

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>

using namespace std;

int main()

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

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

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:

#include <iostream>
using namespace std;

int main()

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)

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.

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:

velocidad = 299792458;

A que diga

velocidad = VELOCIDAD_LUZ;

Pues en el segundo caso, queda muy claro que estamos asignando el valor de
velocidad con el de la luz, que es una constante. Por supuesto, anteriormente
tendríamos que haber declarado la constante VELOCIDAD_LUZ con su respectivo
valor

Entrada y salida de datos en C++. Uso de

cin, cout, scanf y printf
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 complicado.
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++.
Este orden se debe a que cuando queremos pedirle algún dato al usuario primero
debemos hacerle saber lo que queremos 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, junto con <<. 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++, usando cout

#include "iostream"

using namespace std;

int main()

//Se muestra un mensaje por pantalla.

cout << "Hola Mundo" << " Desde ProgramarYa." << "\n";

return 0;

El ejemplo que acabas de ver es bastante sencillo, excepto por un detalle. Si

ejecutar este código en tu pantalla aparecerá un mensaje diciendo "Hola Mundo
Desde ProgramarYa.". 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 "\n" 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++, usando cout

#include "iostream"

#include "string"

using namespace std;

int main()

//El valor de esta variable se mostrará en pantalla

 string salida1 = "Ejemplo de salida";

//Este valor también se mostrará en pantalla.

int numero = 2;

//Estos valores se concatenarán en una única salida

string salida2 = "Desde ProgramarYa.";

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

cout << salida1 << " " << numero << ". " << salida2 << "\n";

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.).

Ahora, veamos los mismos ejemplos, pero usando la función printf de C++, la cual
también es útil para imprimir valores por pantalla

Ejemplo 1 de impresión de texto por pantalla en C++, usando printf

#include "iostream"

using namespace std;

int main()

//Se muestra un mensaje por pantalla.

printf("Hola Mundo");
 printf(" Desde ProgramarYa.");

printf("\n");

//Alternativamente

printf("Hola Mundo Desde ProgramarYa.\n");

return 0;

Al ejecutar el código, el resultado sería el mismo del ejemplo de cout: "Hola Mundo
Desde ProgramarYa", con su respectivo salto de línea al final. Sin embargo, el
código es bastante diferente, pues printf no nos permite concatenar valores
directamente en un solo llamado, así que debemos hacer llamadas sucesivas para
imprimir cada parte del mensaje. Por supuesto, podrías simplemente hacer un solo
llamado a printf con el mensaje completo y sería mucho más sencillo.

Adicionalmente, los llamados a printf requieren que los valores estén al interior de

los paréntesis (), pues printf es más una función que una instrucción propia de C+
+.

Es cuestión de gustos, pero siempre me ha parecido que cout simplifica bastante

las cosas. Veamos ahora el segundo ejemplo usando printf, porque la cosa se
complica:

Ejemplo 2 de impresión de texto por pantalla en C++, usando printf

#include "iostream"

#include "string"

using namespace std;

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 ProgramarYa."; //Estos valores se concatenarán en una

única salida

//Se concatenan y muestran los valores por pantalla con parámetros de printf

printf("%s %d. %s \n", salida1.c_str(), numero, salida2.c_str());

return 0;

En este ejemplo usando printf, puedes ver que inicialmente todo es igual, pero al
momento de imprimir, todo cambia. Cuando nec esitas pasar valores a printf, lo
haces con un "%" seguido de una letra. En el caso de un string se usa s (%s) y en
el caso de un número, se usa d (%d). Y luego, se pasa como una serie de
argumentos, cada uno de los valores a usar en ese mismo orden.

Ahora bien, la cosa es aún más compleja en el caso de string, porque printf no
soporta el uso de string, así que debemos pasar es un apuntador a una seria de
char. Por suerte, eso se consigue llamando a la función "c_str()" propia de string.

Entrada o lectura de datos en C++

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 vaya 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 >>).

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++, usando cin

#include "iostream"

#include "string"

using namespace std;

int main()

cout << "Hola! Este es un ejemplo en C++" << "\n" << "Por favor ingrese su
nombre:" << "\n";

//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" << "\n";

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ó una variable
llamada nombre y luego se usó cin >> nombre indicando que lo que el usuario
ingrese se almacenará en dicha variable.

Ahora bien, el ejemplo anterior es funcional. Sin embargo, presenta problemas

para mostrar los valores, cuando el nombre que ingresas contiene espacios. Y
como es muy posible que un nombre contenga espacios, debemos repararlo.

Ejemplo 1 (mejorado) para leer de datos en C++, usando getline y cin

#include "iostream"
#include "string"

using namespace std;

int main()

cout << "Hola! Este es un ejemplo en C++" << "\n" << "Por favor ingrese su
nombre:" << "\n";

//Volvemos a mostrar el mismo mensaje, pues para mostrar datos no hay

problemas

string nombre;//Seguimos usando string para almacenar el nombre

//cin >> nombre; //Esta línea da problemas si se lee un valor con espacios

// En su lugar, usamos getline, con el flujo de entrada de cin y lo asignamos as

nombre

getline(cin, nombre); //Esta línea no dará problemas con los espacios en el

nombre

cout << "Bienvenido al sistema " << nombre << ". Gracias por usar nuestra
aplicación" << "\n";

return 0;

En este ejemplo hemos hecho exactamente lo mismo, pero hemos modificado el

modo de leer la información desde la consola, de modo que, aunque el valor del
nombre incluya espacios, no haya fallas y se use el valor completo introducido por
el usuario.

Veamos ahora otro ejemplo, pero para leer números:

Ejemplo 2 de lectura de datos en C++, usando cin

#include "iostream"
#include "string"

using namespace std;

int main()

//Mensaje de bienvenida

cout << "Hola! Aqui podras realizar sumas" << "\n";

//Se declaran los números que se sumarán (pueden ser decimales)

float numero1, numero2;

//Se pide el primer numero

cout << "Por favor ingrese el primer valor: " << "\n";

//Se asigna el primer valor a numero1

cin >> numero1;

//Se pide el segundo numero

cout << "Por favor ingrese el segundo valor: " << "\n";

//Se asigna el segundo valor a numero2

cin >> numero2;

//Se muestra el resultado.

cout << numero1 << " + " << numero2 << " = " << numero1 + numero2;

return 0;

Acá tienes un caso similar al anterior, pero en esta ocasión se están solicitando
números y luego realizando operaciones matemáticas con ellos.
Vamos ahora a hablar un poco del uso de scanf para leer valores y algunas
dificultades que esto presenta.

Uso de scanf para leer valores y cadenas de texto (string) en C++

El operador scanf al igual que printf fueron ideados para el lenguaje C (no para C+
+), por lo cual su uso es más primitivo y, en cierto modo, complejo. Leer datos con
scanf implica comprender un poco el concepto de punteros y particularmente en el
caso de string (que es una librería de C++) se complica aún más, pues debemos
convertir ese string en un array definido de caracteres (char).

Vamos a ver un único ejemplo sobre el uso de scanf y string en C++ para quedar
claros acerca de estas dificultades

#include "string"

using namespace std;

int main()

char temporal[100];

printf("Tu nombre?\n");

scanf("%100s", temporal);

string nombre = temporal;

printf("Te doy la bienvenida %s", nombre.c_str());

return 0;

Como puedes ver, necesitamos seguir usando la sintaxis tipo "%s" para leer una
serie de caracteres, pero en esta ocasión debimos además especificar el tamaño
del mismo (100). Adicionalmente, en los siguientes argumentos de scanf, pasamos
entonces el nombre de la variable a la cual asignar el valor ingresado por el
usuario
Ahora, es un código un tanto curioso. Y siendo sincero, el uso de string es
completamente innecesario en ese código (por desgracia). Tanto scanf como printf
nos obligan a usar tipos muy primitivos, como char, así que si queremos usar
string es poco lo que podemos hacer, pues aunque en nuestro código finalmente
hemos usado string, en realidad se trata de un array de 100 caracteres (char)
disfrazado.

El código funciona y te permitirá entonces leer valores por medio de scanf y

asignarlos a una variable. Esto funciona muy bien con números, pero con string o
básicamente en este caso un array de caracteres, debemos lidiar con tamaños
constantes (como el 100 que tenemos allí).

Algunas recomendaciones y comentarios al leer y escribir datos en C++

 Primero que todo, aunque los puedes usar, no recomiendo para nada el uso
de scanf y printf, pues complican demasiado el código y pierdes mucha
flexibilidad. En realidad, tanto scanf como printf son de C y no de C++, así
que deberías usar siempre cout y cin en lugar de printf y scanf
(respectivamente), no tienes razones para complicarte la vida sin
necesidad.
 Finalmente, recuerda siempre que cin va acompañado de ">>", mientras
que cout usa "<<" (notar que van en sentido contrario). EN realidad, cin
dirige el flujo de dastos hacia la variable (por ello va a la derecha ">>"),
mientras que cout lo dirige hacia la salida del sistema (por eso va hacia la
izquierda "<<".
 Una vez más, el uso de printf y scanf no es recomendable, porque además
de ser bastante más complejos, pueden incluso acarrear a problemas de
seguridad en tus programas. La complejidad de estas librerías es
simplemente innecesaria en los tiempos actuales.

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 parea definir ciertas acciones condiciones especificas en nuestro
algoritmo. Un condicional, permite establecer una serie de condiciones al interior
de nuestro programa, que nos ayudan a determinar que 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 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 cual usar en
qué momento, veremos también el concepto de condicionales anidados, y algunas
otras cositas

Te recuerdo, que aunque intentaré profundizar bastante en cada concepto, lo 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, te invito a que primero leas
la sección de Fundamentación de los Condicionales, en dicha sección podrás
comprender correctamente el funcionamiento de un condicional y de cada tipo de
estos y posteriormente podrás regresar a esta sección para aprender a
implementar un condicional en C++ de manera mucho mas fácil y adecuada.
Condicional if en C++. Declaración, uso y sintaxis del if en C++

Los condicionales if, son una estructura de control condicional, también llamadas
estructuras selectivas de casos simples (porque solo definen un posible flujo), lad
cuales nos permiten tomar cierta decisión al interior de nuestro algoritmo, es decir,
nos permiten determinar qué acciones ejecutar según cierta condición sea
verdadera, por ejemplo determinar si un número cualquiera es mayor que 10 y de
acuerdo a esto mostrar un mensaje (o cualquier acción que sea necesaria).

Básicamente, un condicional if, es una estructura que nos posibilita definir las
acciones a ejecutar si se cumple cierta condición y de ese modo modificar la
ejecución de tareas en un programa según se necesite.

¿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.

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 ejecutara 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

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 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 dejarlas en la sección de comentarios

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.

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"

using namespace std;

int main()

int resultado = 0;

cout << "Cuanto es 39+50? ";

cin >> resultado;

if(resultado == 39+50)

cout << "Respuesta Correcta. Felicitaciones!\n";

system("PAUSE");

}
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
que 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.

Se les conoce también como estructuras selectivas de casos dobles (porque

definen ambas posibilidades en la ejecución --si se cumple y si no se cumple --).

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;
generando así una separación o bifurcación en la ejecución del programa,
ejecutando ciertas acciones u otras a partir de la evaluación de una condición
dada.

¿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 con 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.
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:

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....

....

....

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 que bloque
de instrucciones ejecutar.

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 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

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++

A continuación vamos a ver unos cuantos ejemplos para comprender de manera

adecuada el uso de 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 dejarlas en la sección de
comentarios
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.

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 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 << "Contrasenia correcta. Bienvenido";

else

cout << "Contrasenia incorrecta.";

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

#include "iostream"
#include "string"

#include "stdlib.h"

using namespace std;

int main()

string password = "";

cout << "Ingrese la contrasenia: ";

cin >> password;

if(password == "myClave")

cout << "Contrasenia correcta. Bienvenido";

else

cout << "Contrasenia incorrecta.";

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. 

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.

¿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 un condicional Switch es bastante distinta a la de un condicional

típico, 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;

case valor2: //Bloque de instrucciones 2;

break;

case valor3: //Bloque de instrucciones 3;

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 de ningún caso

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:

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 numero, 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.

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, te
recomiendo visitar la sección de comentarios.

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++

A continuación vamos a ver unos cuantos ejemplos para comprender de manera

adecuada el uso de 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 dejarlas en la sección de
comentarios

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.

Solución Ejemplo 1:

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;

case 2: cout << "Usted ha seleccionado la opción 2";

 break;

case 3: cout << "Usted ha seleccionado la opción 3";

break;

default: cout << "Usted ha ingresado una opción incorrecta";

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

# include "iostream"

using namespace std;

int main()

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;

case 2: cout << "Usted ha seleccionado la opción 2";

 break;

case 3: cout << "Usted ha seleccionado la opción 3";

break;

default: cout << "Usted ha ingresado una opción incorrecta";

// system("PAUSE"); //Solo ponla si no te da error

return 0;

Ejemplo 2: Menú de opciones en C++, usando char

Vamos a retomar el ejemplo anterior, pero en esta ocasión vamos a usar

caracteres (char) de C++, para determinar las opciones ingresadas por el usuario.

Solución Ejemplo 2, usando char:

Veamos entonces como hacer esto:

cout << "Ingrese la Opción a ejecutar: ";

char opcion;

cin >> opcion;

switch(opcion)

case 'a': cout << "Usted ha seleccionado la opción a";

break;

case 'b': cout << "Usted ha seleccionado la opción b";

 break;

case 'c': cout << "Usted ha seleccionado la opción c";

break;

default: cout << "Usted ha ingresado una opción incorrecta";

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

# include "iostream"

using namespace std;

int main()

cout << "Ingrese la Opción a ejecutar: ";

char opcion;

cin >> opcion;

switch(opcion)

case 'a': cout << "Usted ha seleccionado la opción a";

break;

case 'b': cout << "Usted ha seleccionado la opción b";

break;

case 'c': cout << "Usted ha seleccionado la opción c";

break;

default: cout << "Usted ha ingresado una opción incorrecta";

 }

// system("PAUSE"); //Solo ponla si no te da error

return 0;

Eso es todo. Como ves, en esencia es el mismo código, pero debes asegurarte de
poner las diferentes opciones entre comillas simples ('), puesto que la
comparación es entre caracteres.

Detalles sobre el condicional switch en C++

 En C++, NO puedes usar otra cosa diferente a número en cada case. Si
necesitas comparar cadenas de texto u otros tipos de datos, seguramente
un condicional como el if o if-else sean una mejor alternativa
 Los caracteres también se pueden usar, pues en esencia se pueden
representar como números enteros (el lenguaje se encarga de eso por ti).
Sin embargo, como indiqué, otros tipos de datos no son recomendables
 La sentencia default es opcional, así que si no lo deseas no la debes poner.
Sin embargo, es recomendable hacerlo, para así controlar todas las
opciones posibles y que tu programa no quede a la "suerte" en ciertos
casos.
 Dentro de cada case eres libre de poner varias líneas de código, incluso
otras estructuras como condicionales o ciclos. Sin embargo, es preferible
mantener tu código ordenado y no poner muchas. Recomendaría no poner
más de 5 y preferiblemente solo una. Si deseas hacer tareas complejas al
interior de un case de un switch en C++, posiblemente sea mejor hacer
esas tareas en una función y llamar a esa función desde el case o
simplemente usar un if-else.

Así que, efectivamente, los condicionales switch y 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. 

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 cual 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 primero leas la sección de Fundamentación de los Ciclos,
en dicha sección podrás comprender correctamente el funcionamiento de un ciclo
y posteriormente podrás regresar a esta sección para aprender a implementar los
ciclos en C++

Ciclo for en C++. Estructura, sintaxis y uso de un ciclo for en C++

Los ciclos for son lo que se conoce 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

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....

....

....

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 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 ultimo componente de esta primer línea es el tamaño
del paso, este componente se especifica aumentando en la cantidad deseada la
variable de control.

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 ejecutaran cada vez
que el ciclo de un "giro". Esta llave no es del todo obligatoria, sin embargo si no la
ponemos solo se ejecutara 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.

Ejemplos de Ciclo For en C++

A continuación vamos a ver unos cuantos ejemplos para comprender de manera

adecuada el uso de 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, puedes dejarlas en la sección de comentarios

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 numero 50 y el 100, es un ejemplo sencillo con el que nos aseguraremos
de haber comprendido bien lo anterior:

Solución Ejemplo 1:

Como pudimos ver anteriormente, tenemos entonces que el valor inicial para
nuestro ciclo es el numero 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;

}

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

#include "iostream"

#include "stdlib.h"

using namespace std;

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;

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:

Solución Ejemplo 2:

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 << i << endl;

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

#include "iostream"

#include "stdlib.h"

using namespace std;

int main()

for(int i=10; i > 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 10987654321

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.

Solución Ejemplo 3:

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;

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

#include "iostream"

#include "stdlib.h"

using namespace std;

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.
Ciclo while en C++. Estructura y sintaxis. Cómo y para qúe 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 cuando 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 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 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 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

{
....
....
Bloque de Instrucciones....
....
....
}

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 mas 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 ejecutara 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

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 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++

A continuación vamos a ver unos cuantos ejemplos para comprender de manera

adecuada el uso de los ciclos while 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 dejarlas en la sección de comentarios

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
mas es un ejemplo sencillo con el que nos aseguraremos de haber comprendido
bien todos los conceptos anteriores:

Solución Ejemplo 1:

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 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"

using namespace std;

int main()
{
int numero;
cout << "Ingrese un numero ";
cin >> numero;
while(numero <= 100)
{
cout << "Ingrese un numero ";
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 aun como
usarlos de manera efectiva.

Ciclo do-while en C++. Estructura, sintaxis y diferencias con el while. Cómo y

cuándo 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 cuando 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 usuario una serie de números cualquiera y
que solo dejaremos de hacerlo cuando el usuario ingrese 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 especifica, 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
numero 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 numero 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
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

....

....

Bloque de Instrucciones....

....

....

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

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 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 l alinea 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.

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 Ciclo Do-While en C++

A continuación vamos a ver unos cuantos ejemplos para comprender de manera

adecuada el uso de los ciclos while 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 dejarlas en la sección de comentarios.

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
mas 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:

Solución Ejemplo 1:

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 numero 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

cout << "Ingrese un numero ";

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"

using namespace std;

int main()

int numero;

do

cout << "Ingrese un numero ";

cin >> numero;

while(numero <= 100);

system("PAUSE");

return 0;

Nota: 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.

Diferencias entre el ciclo do-while en C++ y el ciclo while

Cuando vemos por primera vez el ciclo do-while, se nos viene de inmediato la
pregunta de cuál es la diferencia entre un do-while y un while. Y no quedamos
muy seguros de poder saber cuándo usar uno u otro, así que aquí te explico.

La diferencia es que el do-while, primero ejecuta la acción y luego evalúa la

condición, mientras que el while evalúa la condición antes que cualquier cosa.
Esto quiere decir, que el ciclo while podría no ejecutar ni siquiera una vez lo que
tenga en su interior, mientras que el do-while te asegura que lo que pongas dentro
se ejecute mínimo una vez, pues primero ejecuta y luego evalúa la condición.
Ejemplo de diferencias entre un do-while en C++ y un while

Como siempre, un ejemplo puede ayudarnos mucho más a comprender cuándo

usar un do-while en lugar de un while en C++, así que vamos a implementar el
siguiente ejemplo:

Vamos a suponer que queremos mostrar un menú de opciones a un usuario de

nuestro programa y que mientras la opción ingresada no sea cero, entonces no
finalizamos el programa.

Implementando el ejemplo del menú de opciones con un ciclo do-while (el

recomendado)

#include "iostream"

using namespace std;

int main()

int opcion = 0;

do

cout << "Ingrese 1 para mostrar mensaje\n";

cout << "Ingrese 2 para hacer algo más\n";

cout << "Ingrese 0 para salir\n";

cout << "Ingrese una opción a ejecutar\n";

cin >> opcion;

//Mostramos el menú hasta que la opción sea cero

while(opcion != 0);
 system("PAUSE");

return 0;

Como puedes ver y comprobar, es un código sencillo y mientras que el usuario del
programa no ingrese cero en la consola, el programa seguirá mostrando las
diferentes opciones.

Es importante notar que, incluso aunque la variable "opcion" se inició en cero, el

ciclo do-while mostró las opciones sin problemas y no llegó a evaluar su valor,
únicamente después de que el usuario la ingresó. Veamos ahora el mismo
ejercicio, pero usando un ciclo while.

Implementando el ejemplo del menú de opciones con un ciclo while (no

recomendado)

#include "iostream"

using namespace std;

int main()

int opcion = -1;

//Mostramos el menú hasta que la opción sea cero

while(opcion != 0)

cout << "Ingrese 1 para mostrar mensaje\n";

cout << "Ingrese 2 para hacer algo más\n";

cout << "Ingrese 0 para salir\n";

cout << "Ingrese una opción a ejecutar\n";

cin >> opcion;

 }

system("PAUSE");

return 0;

En este caso, vemos que, por supuesto, con el ciclo while también podemos
conseguir lo mismo, PERO modificando algunas cosas con relación a la opción.
En general, el mayor aspecto negativo de usar un while en este caso, en lugar de
un do-while, es que ya hemos evaluado la opción sin siquiera habérsela solicitado
al usuario por primera vez, lo cual nos obliga a darle un valor inicial a la variable
"opcion" (un -1), para asegurarnos de que el ciclo se ejecute al menos una vez y el
usuario tenga la opción de ver el menú e ingresar la acción que desea ejecutar.

Muy bien, con eso deberíamos tener un caso claro en el que es mejor usar un do-
while que un while en C++. Veamos ahora algunas conclusiones.

Conclusiones sobre el ciclo do-while en C++

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 aun 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++.

¿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++)

{
/*
 ....
....
Bloque de Instrucciones....
....
....
*/
for(int j = valor inicial; j < valor final; j++)
{
/*
....
....
Bloque interno de Instrucciones....
....
....
*/
}
//Acá pueden haber más instrucciones
}

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.
Nota: Cabe mencionar que no he 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)
{
/*
Bloque de Instrucciones....
*/

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.

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úmero del 1 al 100 (1x1 hasta
10x10).

#include "iostream"
using namespace std;

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);
//(i+1)*(j+1) va desde 1x1 hasta 10x10 (aunque en desorden)
}
}
system("pause");
return 0;
}

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"
using namespace std;

int main()
{
//Suponiendo que tenemos una matríz llena llamada matrix
for(int i = 0; i < 10; i++)//Ciclo externo
{
//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:

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"
using namespace std;
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);
//(i+1)*(j+1) va desde 1x1 hasta 10x10
}
}

for(int i = 0; i < 10; i++)//Ciclo externo

{
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;
}
Nota: Recuerda que si no es clara alguna de las líneas de estos códigos
anteriores, te recomiendo visitar los contenidos anteriores o dejar un comentario al
final de la sección con tu pregunta.

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 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á
cuando es realmente necesario usarlos.

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.

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 titulo 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
titulo 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 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 circunstancia 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 validas y vamos a ver ambas,
usando vectores en esta sección y usando matrices en la sección de matrices.

Nota: 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. Si buscas cómo
crear vectores de tamaño dinámico o matrices de tamaño dinámico, te recomiendo
ver la sección de Punteros en C++. No te recomiendo ver esa sección sin antes
haber entendido esta.

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.
¿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[tamanio];

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.

Línea 2
Esta línea contiene la declaración de un vector llamado my_vector2, el cual
contendrá un máximo de 25 elementos de tipo float.

Línea 3

Esta línea contiene la declaración de un vector llamado my_vector3, el cual

contendrá un máximo de 500 elementos de tipo string.

Línea 4

Esta línea contiene la declaración de un vector llamado my_vector4, el cual

contendrá un máximo de 1000 elementos de tipo booleano.

Línea 5

Esta línea contiene la declaración de un vector llamado my_vector5, el cual

contendrá un máximo de 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

validas, ya es cuestión de nuestras necesidades y conocimientos determinar cuál
es útil y en qué momento. Veamos entonces:

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 destacara 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 és 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 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
numero 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, estos 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 aun 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 aun, como obtener
un valor específico dentro del array. Veámoslo:

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 esta 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 mas 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:

Nota: 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, es
por esto que explico cómo hacerlo.

#include "iostream"

using namespace std;

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 numero, 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 mas detalles de esto, verifica la
información sobre el operador sizeof.

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 esta 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:

#include "iostream"

using namespace std;

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 " << i + 1 <<"********:\n";

cout << "Titulo: ";

cin >> 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
titulos y autores es char por lo tanto debes ingresar un único caracter 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.

Nota: 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 en la sección de comentarios.

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 titulo o un
autor podamos poner textos completos:

#include "iostream"

#include "string"

using namespace std;

int main()

string titulos[5];

string autores[5];
 cout << "Por favor ingrese la siguiente información de los Libros: \n";

for(int i = 0; i < 5; i++)

cout << "\n******* Libro " << i + 1 << "********:\n";

cout << "Titulo: ";

cin >> titulos[i];

cout << "Autor: ";

cin >> autores[i];

Muy bien, tal como dije en el ejemplo anterior ahora ya podemos ingresar más de
un caracter 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 funcion 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

(discubierto gracias a sus comentarios), 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 interpresta 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
[Link] 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:

#include "iostream"
#include "string"

using namespace std;

int main()

string titulos[5];

string autores[5];

cout << "Por favor ingrese la siguiente información de los Libros: \n";

for(int i = 0; i < 5; i++)

cout << "\n******* Libro " << i + 1 << "********:\n";

cout << "Titulo: ";

//cin >> 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.
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.

Nota: Te recomiendo ver y comprender la sección de arrays o vectores, antes de

iniciar con este artículo para poder dominar el tema de éste 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 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++

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];

Nota: 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++.

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

Esta línea contiene la declaración de una matriz llamada myMatriz2 que tendrá 5
filas y 10 columnas y cada una de las 50 casillas tendrá datos de tipo flotante.

Línea 3

Esta línea contiene la declaración de una matriz llamada myMatriz3 que tendrá 15
filas y 15 columnas (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.

¿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
validas, 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 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:

Nota: 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>

using namespace std;

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

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 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"
using namespace std;

int main()

string libros[5][2];

cout << "Por favor ingrese la siguiente información de los Libros: \n";

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 titulo y en la columna uno (1) el autor.

Por cada libro que queremos agregar, debemos especificar su título y su autor.
Por ello, la segunda posición que se specifica 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.

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
artículo 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 artículo 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 una 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:

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

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 la
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:

#include "iostream"

#include "stdio.h"

using namespace std;

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 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 mencioné al comienzo del artículo, 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:

#include "iostream"

#include "stdio.h"

#include "string"

using namespace std;

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

//Declaramos un arreglo del tamaño ingresado para los titulos

titulos = new string[tamanio];

//Declaramos un arreglo del tamaño ingresado para los autores

autores = new string[tamanio];

cout << "Por favor ingrese la siguiente información de los Libros: \n";

for(int i = 0; i < tamanio; i++)

cout << "\n******* Libro " << i + 1 << "********:\n";

cout << "Titulo: ";

//cin >> 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;

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:

#include "iostream"

#include "stdio.h"

#include "string"

using namespace std;

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

cout << "Por favor ingrese la siguiente información de los Libros: \n";

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;

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.

Nota: La instrucción new utilizada con los strings es necesaria para asignar el

espacio en memoria para esa colección de elementos. No te preocupes por ello de
momento, solo asegúrate de usarla y ya el lenguaje se hará cargo del resto.

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.