Proposiciones para el control de flujo de programa.
Bloques de sentencias.
En este capítulo, denominaremos BLOQUE DE SENTENCIAS al conjunto de sentencias individuales incluidas dentro de un par de llaves. Por ejemplo:
{
sentencia 1;
sentencia 2;
...
sentencia n;
}
Este conjunto se comportará sintácticamente como una sentencia simple y la llave de cierre del bloque no debe ir seguida de punto y coma.
Un ejemplo de bloque ya visto, es el cuerpo del programa principal de la función main().
main()
{
bloque de sentencias
}
En las proposiciones de control de flujo de programa, trabajaremos alternativamente con sentencias simples y bloques de ellas.
Proposición IF-ELSE.
Sirve para ejecutar ciertas sentencias de programa, si una expresión resulta cierta u otro grupo de sentencias, si aquella resulta falsa. Su interpretación literal sería: "Sí es cierta tal cosa, hago tal acción, sino lo es, salta la condición."" El caso más sencillo sería:
if (expresión) sentencia;
La sentencia sólo se ejecutará si el resultado de "expresión" es distinto de cero (cierto), en caso contrario el programa
salta dicha sentencia, realizando la siguiente en su flujo.
Proposición switch.
El switch es una forma sencilla de evitar largos, tediosos y confusos anidamientos de if-else if.
Supongamos que estamos implementando un menu, con varias elecciones posibles. El esqueleto de una posible solución al problema
usando if-else podía ser el siguiente:
#include <stdio.h>
main()
{
int c;
printf("\n MENÚ");
printf("\n A = ADICIONAR A LA LISTA ") ;
printf("\n B = BORRAR DE LA LISTA ") ;
printf("\n O = ORDENAR LA LISTA ") ;
printf("\n I = IMPRIMIR LA LISTA ") ;
printf("\n\n ESCRIBA SU SELECCION , Y LUEGO ENTER : ") ;
if( (c = getchar()) != '\n' ) {
if( c == 'A')
printf("\nUD. SELECCIONO AGREGAR") ;
else
if( c == 'B')
printf("\nUD. SELECCIONO BORRAR") ;
else
if( c == 'O' )
printf("\nUD. SELECCIONO ORDENAR") ;
else
if( c == 'I' )
printf("\nUD. SELECCIONO IMPRIMIR") ;
else
printf("\n\a\aUD. APRETO UN CARACTER ILEGAL" ) ;
}
else printf("\n¡ NO HA SELECCIONADO NADA !" ) ;
}
Como es fácil de ver, cuando las opciones son muchas, el texto comienza a hacerse
difícil de entender y engorroso de escribir. El mismo progrma, usando la sentencia switch, quedaría:
#include <stdio.h>
#include <conio.h>
main()
{
int c ;
printf("\nMENU :") ;
printf("\n A = ADICIONAR A LA LISTA ") ;
printf("\n B = BORRAR DE LA LISTA ") ;
printf("\n O = ORDENAR LA LISTA ") ;
printf("\n I = IMPRIMIR LA LISTA ") ;
printf("\n\nESCRIBA SU SELECCION , Y LUEGO ENTER : ") ;
c = getchar() ;
switch (c) {
case 'A' :
printf("\nUD. SELECCIONO AGREGAR") ;
break ;
case 'B' :
printf("\nUD. SELECCIONO BORRAR") ;
break ;
case 'O' :
printf("\nUD. SELECCIONO ORDENAR") ;
break ;
case 'I' :
printf("\nUD. SELECCIONO IMPRIMIR") ;
break ;
case '\n':
printf("\n¡ UD. NO HA SELECCIONADO NADA !" ) ;
break ;
default :
printf("\n\a\aUD. APRETO UN CARACTER ILEGAL" ) ;
break ;
}
}
El switch empieza con la sentencia:
switch (expresion)
La expresión contenida por los paréntesis debe ser entera, en nuestro caso es un caracter;
luego mediante una llave abre el bloque de las sentencias de comparación. Cada una de ellas se
representa por la palabra clave "case" seguida por el valor de comparación y termina por dos puntos.
Seguidamente se ubican las sentencias que se quieren ejecutar, en el caso que la comparación resulte
cierta. En el caso de resultar falsa, se realizará la siguiente comparación y así sucesivamente. Prestemos atención también a la sentencia break con la que se termina cada case. Una característica poco obvia del switch, es que si se eliminan los break del progrmaa anterior, al resultar cierta una sentencia de comparación, se ejecutarán las sentencias de ese case particular pero también de todos los case's por debajo del que ha resultado verdadero, hasta encontrar un 'break'.
Al final del bloque de sentencias del switch, aparaece una optativa llamada default, que implica, sino se ha sumplido ningun case, ejecute lo que sigue. Es algo superfluo poner el break en este caso, ya que no hay más sentencias después del 'default'.
Iteración WHILE.
El while es una de las tres iteraciones posibles en C. Su sintaxis podría expresarse de la siguiente forma:
while (expresion)
{
proposición_1 ;
proposición_2 ;
...
proposición_n ;
}
Esta sintaxis en palabras significaria; mientras (expresión) dé un resultado CIERTO ejecuto la preposición 1, 2 o 'n'.
Por lo general, dentro de la proposición o del bloque de ellas, se modifican términos de la expresión condicional, para controlar la duración de la iteración.
La iteración Do-While.
Su sintaxis será:
do{
proposición_1;
proposición_2;
...
} while (expresion);
Expresado en palabras es: ejecute las proposiciones, luego repita la ejecución mientras la expresión dé un resultado CIERTO.
La diferencia fundamental entre esta iteración y la iteración anterior es que ésta se ejecuta siempre almenos una vez, sea cual
sea el resultado de expresión.
Iteración FOR.
Es simplemente una manera abreviada de expresar un WHILE, su sintaxis es:
for (expresion1; expresion2; expresion3 ){
proposicion1;
proposicion2;
...
}
Todas estas expresiones, contenidas en el paréntesis del FOR deben estar separadas por punto y coma y NO por comas simples. No es imprescindible que existan todas las expresiones dentro del paréntesis del FOR, pudiéndose dejar en blanco algunas de ellas. Por ejemplo:
Para salir del bucle en estos dos últimos casos, el programador probablemente lo sacará con un break o un return.for (; expr2; expr3)for (expr1;;)for (;;)
La sentencia break.
Sirve para terminar loops producidos por while, do-while y for antes que cumpla la condición normal de terminación. En el ejmplo siguiente vemos su suo para terminar un while indeterminado.
#include
#include
main(){
char c ;
printf("ESTE ES UN LOOP INDEFINIDO ") ;
while(1){
printf( "DENTRO DEL LOOP INDEFINIDO (apriete una tecla):" ) ;
if( (c = getch()) == 'Q' ) break ;
printf( "\nNO FUE LA TECLA CORRECTA PARA ABANDONAR EL LOOP ") ;
}
printf("\nTECLA CORRECTA : FIN DEL WHILE ") ;
}
Sentencia continue.
La sentencia CONTINUE es similar al break con la diferencia que en vez de terminar violentamente el loop, termina con la realización de una iteración particular y permitiendo al programa continuar con la siguiente.
La función exit()
La función exit() tiene una operación mucho más drástica que las anteriores, en vez de saltear una iteración o abandonar
un lazo de programa, esta abandona directamente al programa mismo dándolo por terminado. Realiza también una serie de
operaciones útiles como ser, el cerrado de cualquier archivo que el programa hubiera abierto, el vaciado de los buffers de
salida, etc.
Normalmente se la utiliza para abortar los programas en caso de que se esté por cometer un error fatal e inevitable. Mediante
el valor que se le ponga en su argumento se le puede informar a quien haya llamado al programa (Sistema Operativo, archivo .bat
u otro programa) el tipo que se cometio.
La sentencia GOTO
GOTO implica un salto incondicional de un lugar a otro del programa. Esta práctica hace que los programas sean difíciles de
corregir o mantener. Si no quedará más remedio que usarlo, (y en programación estructurada siempre hay remedio) debe marcarse
el destino del salto mediante un nombre seguido por dos puntos.
if ( c== 0 ) goto OtroLado;
...
OtroLado:
printf(...)
En este caso si C es cero se salta todas las sentencias entre el if y el destino, continuandose con la ejecución del printf().
El destino puede ser tanto posterior como anterior al GOTO invocante.