ESTRUCTURAS DE REPETICIÓN (BUCLES).

Estos tipos de sentencias son el núcleo de cualquier lenguaje de

programación, y están presentes en la mayor parte de ellos. Nos permiten
realizar tareas repetitivas, y se usan en la resolución de la mayor parte de
los problemas.

1. Bucles "while"

Repite la ejecución de una sentencia o un grupo de ellas mientras se cumpla una

condición
especificada.

Es la sentencia de bucle más sencilla, La sintaxis es la siguiente:

• while (<condición>) <sentencia>

• while (condición de bucle)

{
sentencia 1;
:
sentencia n;
}

La sentencia es ejecutada repetidamente mientras la condición sea

verdadera, ("while" en inglés significa "mientras"). Si no se especifica
condición se asume que es "true", y el bucle se ejecutará indefinidamente. Si
la primera vez que se evalúa la condición resulta falsa, la sentencia no se
ejecutará ninguna vez.

Por ejemplo:

while (x < 100) x = x + 1;

Se incrementará el valor de x mientras x sea menor que 100.

Un error muy común con el while, es poner un punto y coma(;) después de la

(condición) ejemplo while(condicion); ←-esto es y causa un error.

2. Bucle "do while"

Repite la ejecución de una sentencia o un grupo de ellas mientras se cumpla

una condición especificada, al menos una vez.

La sintaxis es la siguiente:
 • do <sentencia> while(<condicion>);

• do{
sentencia 1;
:
sentencia n;
}
while (condición de bucle);

La sentencia es ejecutada repetidamente mientras la condición resulte falsa.

Si no se especifica condición se asume que es "true", y el bucle se ejecutará
indefinidamente. A diferencia del bucle "while", la evaluación se realiza
después de ejecutar la sentencia, de modo que se ejecutará al menos una
vez. Por ejemplo:

do
x = x + 1;
while (x < 100);

Se incrementará el valor de x hasta que x valga 100.

Si sólo consta el do-while de una sentencia, entonces podemos prescindir de

las llaves ({ }).

3. Bucle "for"

Las estructuras de control repetitivas permiten controlar el número de veces

que serán ejecutadas una o más sentencias del programa. Se cuenta con
tres tipos de estas estructuras usualmente denominadas bucles: while, for, y
do–while.
Los bucles o ciclos, repiten una sentencia o secuencia de sentencias un
número de veces. A dichas sentencias se les conoce como cuerpo del bucle,
y a cada repetición del cuerpo del bucle se le llama iteración.

El bucle FOR:
Ejecuta una sentencia o un grupo de sentencias un número fijo de veces.
Se escribe una variable de control del bucle (la cual actúa como un
contador), con su valor inicial. La condición iteración contiene una expresión
lógica que hace que el bucle realice las iteraciones de las sentencias
mientras sean verdadera. Finalmente, en incremento se modifica la variable
de control.

Por último el bucle "for", es el más elaborado. La sintaxis es:

for ( inicialización; condición iteración; incremento )

{ sentencia 1;
:
sentencia n;
}

La sentencia es ejecutada repetidamente hasta que la evaluación de la

condición resulte falsa.
Antes de la primera iteración se ejecutará la inicialización del bucle, que
puede ser una expresión o una declaración. En este apartado se iniciarán las
variables usadas en el bucle. Estas variables pueden ser declaradas en este
punto, pero tendrán validez sólo dentro del bucle "for". Después de cada
iteración se ejecutará el incremento de las variables del bucle.
Todas las expresiones son opcionales, si no se especifica la condición se
asume que es verdadera. Ejemplo:

for(int i = 0; i < 100; i = i + 1);

Las tres expresiones que componen la estructura for en C son opcionales,

por lo tanto se pueden omitir en ciertos casos. Si se omite la primera (la
inicialización de la variable de control), significa que la variable se inicializa
en otra parte del programa. Si se omite la segunda expresión, la estructura
for entraría en un ciclo infinito, lo cual es considerado un error. Si se omite la
tercera expresión significa que la variable de control es calculada dentro del
bloque de for.

Contadores

Un contador es una variable casi siempre de tipo entero cuyo valor se

incrementa o decrementa en cada repetición de un bucle. Es habitual llamar
a esta variable “cont” (de contador) o “i” (de índice).
El contador suele usarse de este modo:

Primero: se inicia antes de que comience el bucle. Es decir, se le da un valor

inicial; por ejemplo:

cont = 5

Segundo: se modifica dentro del cuerpo del bucle. Lo más habitual es que se
incremente su valor en una unidad. Por ejemplo:

cont = cont + 1

Esto quiere decir que el valor de la variable “cont” se incrementa en una

unidad y es asignado de nuevo a la variable contador. Es decir, si “cont”
valía 5 antes de esta instrucción, cont valdrá 6 después. Otra forma típica
del contador es:
 cont = cont – 1

Existen varias formas de incrementar los contadores:

Primera Forma:
cont = cont + 1

Segunda Forma:
cont++

Tercera Forma:
cont +=