1. Bucle: En programación, es una sentencia que se realiza repetidas veces a un
trozo aislado de código, hasta que la condición asignada a dicho bucle deje de
cumplirse.
Generalmente, un bucle es utilizado para hacer una acción repetida sin
tener que escribir varias veces el mismo código, lo que ahorra tiempo, deja el
código más claro y facilita su modificación en el futuro.
El bucle y los condicionales representan la base de la programación
estructurada. Es una evolución del código ensamblador, donde la única posibilidad
de iterar un código era establecer una sentencia jump (que en los lenguajes de
programación fue sustituida por el "ir a" o GOTO).
Además existen 3 tipos de sentencias iteración o bucles que 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.
Sentencias de iteración:
Sinopsis: Son todas aquellas de las sentencias de iteración permiten repetir una
sentencia o conjunto de ellas. Es lo que se denomina ejecutar un bucle. En C++
existen tres formas de iteraciones: los bucles while; do…while y for.
Observe que en todos los casos el bucle puede estar constituido por una
sola sentencia o por varias. En cuyo caso se trata de un bloque de código
delimitado por un par de corchetes { }. Si se trata de una sola sentencia, los
corchetes no son necesarios.
De igual modo el descubrimiento de los bucles se lo debemos a Ada Byron,
así como el de las subrutinas (que no es otra cosa que una función o
procedimiento). Está considerada como la primera programadora, y ella misma se
autodenominaba analista, lo que no deja de ser sorprendente, ya que el primer
ordenador no se construyó hasta un siglo después.

2. Generalmente estas sentencias tienen correspondencia con estructuras de
control equivalentes en pseudocódigo. El pseudocódigo es un lenguaje creado
para expresar algoritmos formalmente y de manera clara. No es en sí mismo un
lenguaje de programación, sino más bien, un lenguaje formal (con reglas muy
estrictas), pero humano, que intenta evitar ambigüedades.
Ejemplo: Un algoritmo para saber si un número N, es primo, puede ser: Cualquier
un número es primo si sólo es divisible entre sí mismo y la unidad.
Por lo tanto, para saber si un número N es primo o no, bastará con dividirlo
por todos los números entre 2 y N-1, y si ninguna división es exacta, entonces el
número n es primo.
Pero hay algunas mejoras que podemos aplicar tales como:
1) La primera es que no es necesario probar con todos los números
entre 2 y N-1, ya que podemos dar por supuesto que si N no es divisible
entre 2, tampoco lo será para ningún otro número par: 4, 6, 8..., por lo tanto,
después de probar con 2 pasaremos al 3, y después podemos probar sólo
con los impares.
2) La segunda es que tampoco es necesario llegar hasta N-1, en
realidad, sólo necesitamos llegar hasta el valor entero más cercano a la raíz
cuadrada de N. Esto es así porque estamos probando con todos los
números menores que N uno a uno. Supongamos que vamos a probar con
un número M mayor que la raíz cuadrada de N. Para que M pudiera ser un
divisor de N debería existir un número X que multiplicado por M fuese igual
a N.
N = M x X.
El caso extremo, es aquel en el que M fuese exactamente la raíz

3. cuadrada de N. En ese caso, el valor de X sería exactamente M, ya que ese
es el valor de la raíz cuadrada de N:
N = M² = M x M.
M
Pero en el caso de que M fuese mayor que la raíz cuadrada de N,
entonces el valor de X debería ser menor que la raíz cuadrada de N. Y el
caso es que ya hemos probado con todos los números menores que la raíz
cuadrada de N, y ninguno es un divisor de N.
Por lo tanto, ningún número M mayor que la raíz cuadrada de N puede
ser divisor de N si no existen números menores que la raíz cuadrada de N
que lo sean.
El pseudocódigo para este algoritmo sería algo parecido a esto:
¿Es N=1? -> N es primo, salir
¿Es N=2? -> N es primo, salir
Asignar a M el valor 2
mientras M <= raíz cuadrada(N) hacer:
¿Es N divisible entre M? -> N no es primo, salir
Si M=2 entondes Asignar a M el valor 3
Si M distinto de 2 entonces Asignar a M el valor M+2
Fin del mientras
N es primo ->salir
Para finalizar tenemos que anexar que los tres bucles más utilizados en
programación son el bucle for (Repetir hasta), el While (Mientras), Do While
(Haga mientras).

4. Tipos de Bucles:
En el Lenguaje de Programación C++ hay tres clases de bucles que son:
1) For (Repita hasta).
2) While (Mientras).
3) Do While (Haga Mientras).
A Continuación le explicaremos detalladamente tanto de forma teórica como
practica cada unos de ellos:
1) Bucle While: Es la sentencia de bucle más sencilla, y sin embargo
es tremendamente potente. En C++ se usa la palabra reservada while (que
significa "mientras"), y sirve para ejecutar el cuerpo del bucle repetidamente
mientras la expresión sea distinta de cero (sea verdadera). El test se hace
antes de ejecutar el cuerpo del bucle, lo que significa que se éste se ejecuta
cero o más veces. De igual modo permite ejecutar repetidamente un bloque
de código mientras se cumpla una determinada condición que es
chequeada antes de cada iteración.
De igual modo se debe utilizar un bucle while cuando es posible que el
cuerpo del bucle no sea ejecutado. Por ejemplo, para leer y procesar el
contenido de un fichero de tamaño desconocido.
Ejemplo Básico:
while( expresión )
{
statement; // cuerpo del bucle
...
}

5. Sintaxis:
while ( <condicion> ) <sentencia> ;
Descripción:
La sentencia while ejecuta iterativamente el bucle definido por el bloque de
código <sentencia> siempre que el valor devuelto por la expresión <condición>
(que debe estar entre paréntesis) sea cierto.
Nota: recordemos que cierto (true) equivale numéricamente a 1 , mientras que
falso (false) equivale al valor 0.
Puesto que la condición se evalúa antes que cada ejecución del bucle, si al
comienzo <condicion> devuelve falso, <sentencia> no se ejecuta ninguna vez, y el
control pasa a la siguiente sentencia. Si <condición> devuelve cierto se ejecuta el
bucle <sentencia>, y a continuación se vuelve a evaluar <condicion> con lo que se
repite el ciclo.
Ejemplos:
while (*p == ' ') p++;
while ( i<= j) i++;
La sentencia puede estar vacía, realizándose entonces toda la computación
requerida en la cláusula <condición>.
Ejemplo:
while ( getchar() != 'Z' );
Aunque lo normal es que la <sentencia> sea un bloque de código entre
corchetes:
while (i< n)
{

6. cout<<i<<endl;
++i;
}
Explicación de las salidas del programa adjunto antes de leer el comentario
final (esta disposición es muy utilizada en bucles que deben repetirse un número n
de veces).
#include <iostream>
using namespace std;
int main()
{
// ==========
int x = 5, y = 5;
while ( x-- )
{
cout<< "x = " << x <<endl;
}
while ( --y )
{
cout<< " y = " << y <<endl;
}
cout<< "Terminado!!" <<endl;
}
Salida:
x = 4
x = 3
x = 2
x = 1
x = 0
y = 4
y = 3
y = 2

7. y = 1
Terminado!!
Comentario:
En ambas iteraciones, la condición indicada en el paréntesis es chequeada antes
de ejecutar la iteración (la salida en pantalla). La diferencia entre ambos es que el
postdecremento (x--) se realiza después de la evaluación del paréntesis
(comprobación de que su contenido es cierto). En consecuencia, el ciclo del primer
bucle es como sigue:
1) comprobación de que x es cierto (distinto de cero). El resultado, que
denominaremos R, es un bool.
2) decremento unitario de x
3) dos posibilidades:
a) R == true → ejecutar el bucle (salida en pantalla) → volver al
punto 1.
b) R == false → abandonar el bucle.
En cambio, en el segundo bucle, el predecremento (--x) se realiza antes de la
evaluación del paréntesis (comprobación de la condición del bucle). En
consecuencia, el ciclo del segundo bucle puede resumirse así:
1) decremento unitario de x
2) comprobación de que x es cierto (distinto de cero). El resultado, que
denominaremos R, es un bool.
3) dos posibilidades:
a) R == true → ejecutar el bucle (salida en pantalla) → volver al
punto 1.
b) R == false → abandonar el bucle.

8. 2) Bucle do...while: La sentencia do while va un paso más allá que el whiley
es aquella que permite ejecutar repetidamente un bloque de código
mientras se cumpla una determinada condición que es chequeado después
de cada iteración.
El cuerpo del bucle se ejecuta repetidamente mientras la expresión es
distinta de cero (verdadera). El test se hace después de ejecutar el cuerpo del
bucle, por lo que éste se ejecuta al menos una vez.
En otros lenguajes, como PASCAL, se usa para el mismo tipo de bucle la
estructura "repetir...hasta", es decir la sentencia se repite hasta que se cumpla una
determinada condición. La diferencia está en que la lógica es la inversa: la
sentencia se repite mientras la condición sea falsa. El resultado es el mismo, en
cualquier caso.
A diferencia del bucle while, la evaluación de la condición se realiza
después de ejecutar la sentencia, de modo que ésta se ejecutará al menos una
vez.
Por ejemplo:
Do
{
x = x + 1;
}while (x < 100);
En este bucle se incrementará el valor de x hasta que valga 100.
Pero aunque la condición sea falsa, por ejemplo, si x vale inicialmente 200,
la sentencia x = x + 1;, se ejecuta primero, y después se verifica la condición.
Se pueden construir bucles do...while usando bucles while, pero a costa de
repetir la sentencia dos veces:

9. <sentencia>
while(<condición>) <sentencia>
Esto puede hacernos pensar que estos bucles no son necesarios, y
efectivamente, así es. Pero nos facilitan las cosas a la hora de codificar algoritmos
basados en bucles do...while, ya que, por una parte, nos ahorran el trabajo de
escribir dos veces el mismo código, y por otra, disminuyen las posibilidades de
errores en una de las repeticiones, sobre todo al corregir un error en el código,
cuando es más fácil olvidar que estamos corrigiendo un bucle do...while, por lo
que tendríamos que corregirlo dos veces.
De igual forma, no olvidemos que existen sentencias de bloque, que
pueden constar de cientos de sentencias simples, cada una de las cuales puede
ser una sentencia cualquiera de las que estamos estudiando.
Además se debe utilizarse este tipo de bucles cuando el cuerpo debe ser
ejecutado al menos una vez. En particular, en aquellos casos en que el bucle
calcula un valor que es necesario para la condición de terminación. Por ejemplo,
los cálculos iterativos que terminan cuando se da una condición de convergencia,
cuando una expresión calculada dentro del bucle es menor que un determinado
valor.
Sintaxis:
do<sentencia> while ( <condición> );
Descripción:La sentencia do ejecuta repetidamente el bucle definido por el
bloque de código <sentencia> hasta que la sentencia de control <condición>
devuelve el valor falso.
Puesto que el control se evalúa después de cada ejecución del bucle,
resulta que este se ejecuta al menos una vez, aunque <condición> devuelva el
valor falso desde el principio (si requiere que el bucle no se ejecute ninguna vez,
es mejor utilizar while).

10. La forma más genérica de la expresión suele ser:
do
{
<sentencia> ;
} while ( <condición> );
Ejemplo:
Este programa solicita una clave de acceso indefinidamente hasta que el usuario
proporciona una que coincide con el valor almacenado en la matriz checkword.
#include <stdio.h>
#include <string.h>
int main ()
{ // ===================
char checkword[80] = "password";
char password[80] = "";
do
{
cout<< "Introducir clave: "<<endl;
cin>>("%s", password);
} while (strcmp(password, checkword));
return 0;
}
Nota: C++ no dispone en ninguna de sus sentencias de bucle de la opción loop (o
similar), como la ofrecida por otros lenguajes para saltar al principio desde
cualquier punto de la iteración. No obstante, ofrece alternativas que pueden servir
para el caso.

11. 3) Bucle For:Este tipo de bucle es el más elaborado y consiste en que la
sentencia es ejecutada repetidamente mientras la condición resulte
verdadera, o expresado de otro modo, hasta que la evaluación de la
condición resulte falsa.
La sintaxis es:
for ( [<inicialización>]; [<condición>] ; [<incremento>] )
<sentencia>;
Antes de la primera iteración se ejecutará la iniciación del bucle, que puede
ser una expresión o una declaración. En este apartado se suelen iniciar las
variables usadas en el bucle. Estas variables también pueden ser declaradas en
este punto, pero en ese caso tendrán validez (ámbito) sólo dentro del bucle for.
Después de cada iteración se ejecutará el incremento de las variables del
bucle. Este incremento también es una sentencia de asignación, y no tiene por
qué ser necesariamente un incremento.
En general, podemos considerar que la parte de inicialización establece las
condiciones iniciales del bucle, la parte de la condición establece la condición de
salida, y la parte del incremento, modifica las condiciones iniciales para establecer
las de la siguiente iteración del bucle, o para alcanzar la condición de salida.
Todas las expresiones son opcionales, y si no se especifica la condición se
asume que es verdadera.
Ejemplos:
for(inti = 0; i< 100; i = i + 1);
for(inti = 100; i< 0; i = i - 1);

12. Como las expresiones son opcionales, podemos simular bucles while:
for(;i< 100;) i = i + 1;
for(;i++ < 100;);
O bucles infinitos:
for(;;);
En realidad, podemos considerar un bucle for como una extensión de un
bucle while.
La equivalencia entre un bucle for y un bucle while es la siguiente:
[<inicialización>];
while([<condición>]) {
<sentencia>
[<incremento>]
}
Evidentemente, los bucles for no son estrictamente necesarios, (como
tampoco lo son los bucles do...while), pero en muchas ocasiones simplifican el
código de los bucles, haciendo más fácil la comprensión de un programa, ya sea
para su análisis, su modificación o para su depuración.
En un estilo de programación claro, los bucles for se suelen utilizar para
recorrer listas de elementos (como veremos el tema de los arrays). Usados con
esta función, la inicialización se limita a asignar el valor inicial de un índice que
sirve para recorrer la lista, la condición comprueba si hemos llegado al final de la
lista, y el incremento modifica el índice para que apunte al siguiente elemento de
la lista.
Otra cosa, por muy tentador que resulte a veces, debemos intentar
resistirnos a la tentación de usar los bucles for para emular otro tipo de bucles, ya

13. que generalmente, esto puede inducir a malas interpretaciones sobre la finalidad
del código, dificultando la depuración o el análisis.
Veamos un ejemplo sencillo:
inti=0;
for(boolsalir = false; !salir; salir = (i> -5)) i++;
Aunque este bucle funcione, y haga lo que el programador tiene intención
que haga, averiguar cómo lo hace requerirá cierto esfuerzo por nuestra parte.
Supongo que estarás de acuerdo conmigo en que esto se puede expresar más
claramente de otro modo:
i = 0;
do
{
i++;
} while(i <= -5);
Break y continue: Las palabras reservadas break y continue juegan un papel en
las aplicaciones de los bucles con el for infinito y consisten en que cuando se
termina la ejecución del bucle en que se encuentra. Continue hace que el bucle
pase directamente a la siguiente iteración. Además para finalizar podemos decir
que ambos comando deben utilizarse lo menos posible.
Break: Los enunciados break es utilizados para modificar el flujo de control
dentro de un programa.
El break utilizado dentro de las estructuras de control causa la inmediata
salida de dicha estructura (por lo tanto no sigue repitiéndose el bloque y continúa
la ejecución de las instrucciones que le siguen a la estructura de control).

14. La sentencia break se utiliza frecuentemente para poner fin a la tramitación
de un caso particular dentro de una sentencia switch o un ciclo de iteración. La
falta de un proceso iterativo que encierra o sentencia switch genera un error.
Estructura
Saltar declaración:
break;
/*Programa que cuente del 1 al 10 y termine al llegar al 7*/
#include<iostream.h>
void main()
{
intnum=1;
while (num<= 10)
{
if (num == 7)
{
cout<<"n Numero: "<<num;
break;
};
cout<<"n Número: "<<num;
num++;

15. }
cin.get();
cin.get();
}