Sentencias de Control

En C, cualquier expresión finalizada en un punto y coma ; forma una sentencia.
De todos los tipos, las estructuras (o sentencias ) de control son las que controlan la ejecución de las instrucciones de un programa.
La programacion estructurada se basa en la utilización de un reducido número de estructuras
que permiten hacer que un programa sea suficientemente legible, reduciendo considerablemente
el número de errores, y facilitando enormemente la detección y solución de estos.
La característica fundamental de la programación estructurada consiste en que todas las
estructuras tienen un único punto de entrada y un único punto de salida. Esto permite descomponer
fácilmente un problema en subproblemas, reduciendo la complejidad y facilitando la programación.


En C diferenciamos tres tipos de sentencias de control:

1. Sentencias Condicionales
2. Sentencias de Repetición
3. Sentencias de Salto

• Sentencias Condicionales

Hay tres sentencias condicionales en C: if, else y switch


Sentencia if
La sentencia if nos permite elegir si se ejecuta o no un bloque de instrucciones. La "expresión" del if es una expresión que debe ser evaluada: falsa si es cero y verdadera si vale distinto de cero.

Ejemplo:
#include <stdio.h>
int main ()
{
int x;
printf(“Dame un numero”);
scanf(“%d”,&x);
if (x>0) {
printf(“El numero %d es positivo”,x);
}
return 0;
}


Sentencia else
Una sentencia if cuando incluye un else, permite ejecutar un bloque de código si se cumple la condición y otro bloque diferente de código si la condición no se cumple.

Ejemplo:
#include <stdio.h>
void main ()
{
int x;
printf(“Dame un numero: ”);
scanf(“%d”,&x);
if (x>=0) {
printf(“El numero %d es positivo”, x);
} else {
printf(“El numero %d es negativo”, x);
}
}


Sentencia else colgante
Ejemplo:
#include<stdlib.h>
int main()
{
float nota;
printf ("Dame una nota: ")
scanf ("%f", &nota)
if (nota>9){
printf("Sobresaliente");}
else if(nota >=7){
printf("Notable);}
else if(nota >=5){
printf("Aprobado");}
else{
printf ("Suspenso);}
return 0;
}


Sentencia switch
Permite seleccionar entre multiples alternativas posibles. La expresión del switch es una variable int o char, que puede tomar los valores, entre otros, dados por "opción 1", "opcion 2", etc.

Ejemplo:
#include <stdio.h>
void main()
{
int nota;
printf(“Calificación: ”);
scanf(“%d”, &nota);
switch (nota) {
case 0:
case 1:
case 2:
case 3:
case 4:
printf(“Suspenso”);
break;
case 5:
case 6:
printf(“Aprobado”);
break;
case 7:
case 8:
printf(“Notable”);
break;
case 9:
printf(“Sobresaliente”);
break;
case 10:
printf(“Matrícula”);
break;
default:
printf(“Error”);
}
}

• Sentencias de Repetición

Las instrucciones de repetición también llamados bucles, se ejecutan hasta que se cumpla alguna condición predeterminada en el bucle en el caso del “for” o también en los casos del “while” y “do-while”. Podemos destacar los antes mencionados bucles que son los bucles for,while y do-while.



Bucles for:
Tienen una gran potencia y flexibilidad, y tienen un esquema muy sencillo y definido. Este esquema es así:
for(inicialización del bucle; condición; incremento).
Ahora vamos a proceder a definir cada una de las partes del esquema básico, inicialización (exp1): es una asignación que se utiliza para comenzar la variable del bucle, esto es de la variable de la que parte el bucle. Condición (exp2): es una expresión relacional que hace que el bucle concluya cuando no se cumpla. Por último el incremento (exp3): es la parte que determina como cambia la variable hasta que el bucle concluye. Es importante señalar que cada parte ha de ser separado por ; .Para que deje de ejecutarse el bucle como antes hemos mencionado depende de la condición, que deberá de ser falsa para que el bucle se detenga.
Debemos tener en cuenta que a diferencia de otros bucles este no llegará a ejecutarse si la condición es falsa, ya que la condición se comprueba antes de entrar en el bucle.

Un sencillo ejemplo:
#include <stdio.h>
int main( )
{
int x;
for(x=1; x<=100; x++)
printf (“%d”,x);
return 0;
}
Una de las utilidades del bucle for es en el bucle infinito, que pese a que puede hacerse con todos los bucles es el for con el que se usa. Estos bucles infinitos son usados para que el bucle no concluya nunca hasta que en el cuerpo se encuentre un break. Por otro lado la construcción de este bucle for es muy sencilla, for ( ; ; ).



Bucles while:
Tiene cierta semejanza con el bucle for, así es en el uso de una inicialización, una condición y un incremento. Otra de sus similitudes es el momento en el que analizan la condición que en ambos es antes de ejecutar el bucle. Sin embargo, en su esquema básico aunque parezcan diferentes, son el mismo:

while (condición)
{
cuerpo;
incremento;
}

Algunas de las veces podremos saber antes de empezar el bucle cuantas veces se va a ejecutar.



Ejemplo:
char esperar_caracter (void)
{
char c;
c=’\0’;
while (c!=’A’)
c=getchar ( );
return c;
}


Bucles do-while:
Este es el único bucle que al menos se va a ejecutar una vez puesto que este bucle examina la condición una vez se ha ejecutado el bucle, esto es, al final del mismo. El esquema básico de este bucle sería algo así:
do
{
cuerpo;
}
while (condición);

Este bucle es muy útil por ejemplo en menús dado que el menú debe de ejecutarse al menos una vez.

Ejemplo:
#include <stdio.h>
int main()
{
int digito=0;
do {
printf("%d ",digito++);
}
while (digito<=9);
}

• Sentencias de Salto

Hay cuatro sentencias de salto en C: break, return, goto y continue.
Suelen estar condicionadas (que solo las ejecute el programa en un determinado caso).
Se desaconseja la utilización de este tipo de sentencia de control, sobre todo el goto, ya que su uso implica un aumento de la probabilidad de cometer errores, dificulta la legibilidad del código y es mucho mas difícil corregir errores y cambiar secuencias de código.


Sentencia break
La instrucción de salto break se usa para interrumpir (romper) la ejecución normal de un bucle, es decir, la instrucción break finaliza la ejecución de un bucle y, por tanto, el control del programa se transfiere (salta) a la primera instrucción después del bucle.


Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
break;
/* En el caso de que n sea un cero,
el bucle se interrumpe. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );

printf( "Suma: %d", a );
return 0;
}



Sentencia return
La instrucción de salto return es utilizada en lenguaje C para devolver el control de ejecución desde la función que contiene el return a la rutina que la invocó y para indicar el valor de retorno de una función.

Ejemplo:
#include <iostream>
int z;
void funcion();
int main()
{
for(z=0;z<=5;z++)
{
printf("%i\n",z);
funcion();
system("pause");
}
return 0; Indica al ordenador que el programa ha fnalizado sin errores.
}

void funcion()
{
printf("Hola\n");
if(z==3){printf("Z vale 3\n"); return;} El return termina la función y entonces printf("Z no vale 3\n"); no se ejecutará
printf("Z no vale 3\n");
}


Sentencia goto
La instrucción de salto goto se puede usar en un programa, para transferir incondicionalmente el control del mismo a la primera instrucción después de una etiqueta, o dicho de otra forma, al ejecutar una instrucción goto, el control del programa se transfiere (salta) a la primera instrucción después de una etiqueta.

Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
goto etiqueta_1;
/* En el caso de que n sea un cero,
el control de programa salta a la
primera instrucción después de
etiqueta_1. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );

etiqueta_1:
printf( "Suma: %d", a );
return 0;
}



Sentencia continue
La instrucción de salto continue siempre se usa para interrumpir (romper) la ejecución normal de un bucle. Sin embargo, el control del programa no se transfiere a la primera instrucción después del bucle, como sí hace la instrucción break, es decir, el bucle no finaliza, sino que, finaliza la iteración en curso, transfiriéndose el control del programa a la condición de incremento de contadores y después a la condición de salida del bucle, para decidir si se debe realizar una nueva iteración o no.


Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
continue;
/* En el caso de que n sea un cero,
la iteración en curso del bucle
se interrumpe aquí. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );

printf( "Suma: %d", a );
return 0;
}