UNIVERSIDAD POLITECNICA TERRITORIAL DE MERIDA

PROGRAMA NACIONAL DE FORMACION EN INFORMATICA

ALGORITMICA Y PROGRAMACION
PROF. ALBER ROMERO

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

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.