Bucles
ximena2194Tesis12 de Noviembre de 2014
2.231 Palabras (9 Páginas)375 Visitas
1. Introducción.
Una estructura repetitiva se usará para ejecutar un grupo de instrucciones un número determinado de veces. Ese número de veces se controlará por medio de una expresión booleana o condición, cuyo valor será verdadero o falso. Estas estructuras se suelen denominar bucles. Veamos los distintos tipos.
2. Estructura repetitiva ‘mientras’ (while).
En pseudocódigo esta estructura se escribe de la forma:
...
mientras (condición)
Sentencia1
Sentencia2
...
finmientras
...
Al comenzar la ejecución del ‘mientras’, la condición es evaluada. Si su valor es verdadero, se ejecutan las sentencias colocadas entre mientras y finmientras (sentencias del bucle); la línea finmientras provoca un salto hacia arriba, a la línea mientras de nuevo y se vuelve a evaluar la condición. Si su valor es verdadero otra vez, se realizan las mismas acciones, y así sucesivamente. Si en alguna de las repeticiones, al evaluar la condición su valor es falso, la ejecución salta a la sentencia siguiente al finmientras. Si al evaluar la condición por primera vez resulta ser falsa, las sentencias del bucle no se ejecutan ni una sola vez.
No debe olvidarse que la condición debe estar inicializada, es decir que todas las variables que formen parte de la misma deben tener los valores iniciales adecuados. Además dentro del bucle siempre debe existir alguna instrucción que afecte o modifique (actualice) la condición, ya que si no es así, una vez dentro del bucle no se podría salir, siendo un bucle infinito, porque la condición seguiría siendo verdadera en todas las repeticiones.
Podría por tanto escribirse:
...
<Inicializar condición>
mientras (condición)
Sentencia1
Sentencia2
...
<Actualizar condición>
finmientras
...
En C la sintaxis de esta estructura es:
...
while (condición)
{
Sentencia1;
Sentencia2;
...
} //equivale al finmientras
...
Ej.
//Bucle que se repite 10 veces.
numero = 1; //inicializa condición
while (numero <= 10)
{
...
numero = numero + 1; //actualiza condición
}
3. Estructura repetitiva ‘repetir’ (repeat).
En pseudocódigo esta estructura se escribe de la forma:
...
repetir
Sentencia1
Sentencia2
...
hasta (condición)
...
Al comenzar la estructura ‘repetir’, se ejecutan las sentencias colocadas entre repetir y hasta (sentencias del bucle) y después se evalúa la condición. Si su valor es falso, se realiza un salto hacia arriba, hasta la línea repetir, y se ejecutan las sentencias del bucle de nuevo. Si en alguna de las repeticiones, al evaluar la condición su valor es verdadero, la ejecución continúa por la sentencia siguiente a la línea hasta. Como vemos, las sentencias del bucle siempre se ejecutan al menos una vez.
En este tipo de repetitiva también ocurre como en la anterior, es decir antes de evaluar la condición por primera vez debe estar inicializada y además dentro del bucle debe actualizarse dicha condición, para no entrar en un bucle infinito.
En algunos lenguaje existe la sentencia ‘repeat-until’, lo cual no ocurre en C, en el que esta sentencia adopta la sintaxis:
...
do
{
Sentencia1;
Sentencia2;
...
} while (condición);
...
Ello implica que el bucle finaliza cuando la condición es falsa, ya que un mientras expresa la idea contraria a un hasta.
Ej.
//Bucle que suma notas tecleadas, hasta que sea 0.
do
{
scanf(“%d”, ¬a); //inicializa y actualiza
suma += nota; //la condición
}while (nota != 0);
4. Estructura repetitiva ‘para’ (for).
En pseudocódigo esta estructura se escribe de la forma:
...
para <Variable> de <VI> a <VF> con incremento <Inc>
Sentencia1
Sentencia2
...
finpara
...
Este bucle se diferencia de los anteriores porque se repite un número fijo de veces. La <Variable> toma inicialmente el valor <VI> (valor inicial), si ese valor es menor o igual que <VF> (valor final) se ejecutan las sentencias del bucle. A continuación la <Variable> se incrementa en el valor <Inc> y si su valor vuelve a ser menor o igual que <VF>, se ejecutan de nuevo las sentencias. Se vuelve a incrementar la <Variable> en el valor <Inc>, y así sucesivamente, hasta que el valor de <Variable> sea mayor que el valor <VF>, en cuyo caso el programa continúa con la sentencia colocada después del finpara.
Como se ve en esta sentencia, en la misma línea del para se asegura la iniciaización de la condición (VI) y la actualización de la condición (Inc). La sentencia para anterior es equivalente al siguiente while:
...
<Variable> = <VI>
mientras ( <Variable> <= <VF> )
Sentencia1
Sentencia2
...
<Variable> = <Variable> + Inc
finmientras
...
En C la sintaxis equivalente al para es:
...
for (<Vari> = <VI>; <Vari> <= <VF>; <Vari> += Inc)
{
Sentencia1;
Sentencia2;
...
}
...
Aunque la sentencia for tiene un uso más amplio que el para, ya que realmente en la línea for se pueden colocar tres expresiones cualesquiera separadas por punto y coma, incluyendo la expresión nula. Es decir:
...
for (Expresión1; Expresión2; Expresion3)
{
Sentencia1;
Sentencia2;
...
}
...
El funcionamiento de ese bucle es el siguiente: se ejecuta la expresión1; después se evalúa la expresión2, y si es cierta se ejecutan las sentencias del bucle; al llegar a la llave cerrada }, se salta hacia arriba y se ejecuta la expresión3; se vuelve a evaluar la expresión2, y si es cierta, se ejecutan las sentencias del bucle de nuevo; y así sucesivamente, hasta que expresión2 sea falsa, en cuyo caso se continúa por la sentencia colocada después del bucle.
Por tanto, con la sentencia for de C se puede implementar cualquier bucle, ya sea mientras, repetir o para. La expresión1 se suele usar como inicialización de la condición, la expresión2 como condición y la expresión3 como actualización de la condición.
Ej.
//Bucle que se ejecuta 10 veces
for (numero = 1; numero <= 10; numero++)
{
Sentencia1;
...
}
...
//Bucle que suma notas tecleadas, hasta que sea 0.
suma = 0;
for (scanf(“%d”, ¬a);nota != 0; scanf(“%d”, ¬a))
suma += nota;
//Bucle que suma notas tecleadas, hasta que sea 0.
suma = 0;
scanf(“%d”, ¬a)
for ( ;nota != 0; )
{
suma += nota;
scanf(“%d”, ¬a)
}
//Bucle dependiente de 2 variables.
for (x=0, y=0; x+y < 100; x++, y+=2)
{
Sentencia1;
...
}
//Bucle que finaliza al teclear N.
for (car = getche(); car != ‘N’; car = getche())
{
Sentencia1;
...
}
5. Anidamiento de repetitivas.
Como cualquier otra estructura de control, las repetitivas también pueden anidarse, es decir colocar una dentro de otra, lo cual puede hacerse repetidas veces. Una estructura repetitiva es otra sentencia más, por lo tanto puede colocarse en cualquier punto previo marcado como sentencia.
El único criterio a seguir al anidar estructuras, como ya se dijo para las alternativas, es que debe cerrarse siempre la estructura interna antes de hacerlo la externa. O sea, una llave cerrada } cerrará siempre a la estructura más cercana hacia
...