0
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.
|
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 si mismo un lenguaje de programación, sino más bien, un lenguaje formal (con reglas muy extrictas), pero humano, que intenta evitar ambigüedades.
A su vez, un algoritmo es un conjunto de reglas sencillas, que aplicadas en un orden determinado, permiten resolver un problema más o menos complejo.
Por ejemplo, un algoritmo para saber si un número N, es primo, puede ser:
|
Cualquier número es primo si sólo es divisible entre si 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:
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.
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 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 = M2 = M x 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.
|
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 |
Bucles "mientras"
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 la sintaxis es la siguiente:
| while (<condición>) <sentencia> |
La sentencia es ejecutada repetidamente mientras la condición sea verdadera. 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.
Las condiciones no son otra cosa que expresiones de tipo booleano, cualquier otro tipo de expresión se convertirá a tipo booleano, si es posible. Y si no lo es, se producirá un error.
Por ejemplo:
| while (x < 100) x = x + 1; |
Se incrementará el valor de x mientras x sea menor que 100.
Este ejemplo puede escribirse, usando el C++ con propiedad y elegancia (es decir, con clase), de un modo más compacto:
| while (x++ < 100); |
Aquí vemos el uso de una sentencia nula, de la que hablábamos hace un rato. Observa que el bucle simplemente se repite, y la sentencia ejecutada es ";", es decir, nada.
| Nota: En realidad estos dos bucles no son equivalentes, ya que el valor de x al finalizar el segundo bucle es 101, y al finalizar el primero es 100. |
Bucle "hacer...mientras"
Esta sentencia va un paso más allá que el while. La sintaxis es la siguiente:
| do <sentencia> while(<condicion>); |
La sentencia es ejecutada repetidamente mientras la condición resulte verdadera. Si no se especifica condición se asume que es true, y el bucle se ejecutará indefinidamente.
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:
|
<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.
Además, 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.
Bucle "para"
Por último el bucle para, que usa la palabra reservada for. Este tipo de bucle es el más elaborado. La sintaxis es:
|
for ( [<inicialización>]; [<condición>] ; [<incremento>] )
<sentencia>; |
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.
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(int i = 0; i < 100; i = i + 1);
for(int i = 100; i < 0; i = i - 1); |
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 extrictamente 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 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:
|
int i=0;
for(bool salir = 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); |
Comentarios