Estructuras de control

Las estructuras que incorpora el C basadas en la programación estructurada son:

1. Secuenciales.
2. Selectivas.
3. Repetitivas.

• Estructuras Secuenciales

En un programa en C, las sentencias se ejecutan una tras otra en el orden en el que están escritas. El fin de sentencia marca el comienzo de la siguiente.

{ sentencia1; sentencia2; ... sentenciaN;}

• Estructuras Selectivas

También son llamadas condicionales; permiten que ciertas sentencias se ejecuten o no en función de una determinada condición. Tipos de estructuras selectivas:

• la simple: if 

• la doble: if else

• la múltiple: switch

La estructura general de una estructura selectiva simple en C es:
Primero evaluará que la expresión sea verdadera (distinta de cero) para proceder a ejecutar la o las sentencias dentro del bloque_if. Es importante que cuando sean de dos sentencias en adelante dichas sentencias estén dentro de llaves { }.      

     if(expresion)
           bloque_if

La estructura general selectiva doble:

Al igual que la simple, primero evalúa que la expresión sea verdadera, en caso de que si lo sea ejecuta las sentencias que estén en el bloque_if. En caso de que no sea verdadera la expresión ejecutará la o las sentencias que estén en el bloque_else

   if(expresion)
           bloque_if
   else 
           bloque_else

La estructura general selectiva múltiple :

En la estructura selectiva múltiple, se puede seleccionar entre varias alternativas según el valor de una expresión.

        switch(expresion)

      {

            case exprConst1: 

                     listaProp1

                     break;

            case exprConst2:

                     listaProp2

                     break;

            case exprConstN:

                     listaPropN

                     break;

            default: 

                     propDefault

                     break;

        }

Primero se evalúa la expresión que acompaña al switch (se evalúa como expresión entera). 

Se compara el valor obtenido, secuencialmente, con los valores que acompañan los case, deteniéndose en el primero que coincida. Estos valores deberán ser expresiones constantes enteras.

Existe una etiqueta especial, default, que siempre es cierta, por lo que se utiliza para contemplar el resto de los casos que no se han considerado en los case anteriores. Es muy importante que esta etiqueta sea la última.

Al final de cada case se utiliza un break ya que si la expresión coincide con un case se ejecutarán todos los case que estén por debajo, entonces break finaliza la ejecución del switch.

• Estructuras Repetitivas

En este tipo de estructuras, se repite un conjunto de instrucciones en función de una condición. La principal entre las diferentes estructuras repetitivas consiste en qué punto se realiza la comprobación de la condición. Las tres tipos de estructuras repetitivas son:

• while
• do while
• for

Sentencia while:

Primero se evalúa la expresión que acompaña a la cláusula while. Si la expresión es cierta (el valor es distinto de cero), se ejecuta el bloque que sigue a continuación. Se vuelve al primer paso, y se repite el proceso.


Sintaxis:

        while (expresion)

          bloque

Sentencia do while:

A diferencia de la sentencia while. en esta estructura primero se ejecuta el bloque y posteriormente se comprueba la condición. Por lo tanto, el bloque de una sentencia do while se ejecuta siempre al menos una vez.
Sintaxis:

     do

     bloque

  while(expresion);

Sentencia for:

En esta sentencia se ejecuta primero el bloque inicial, se evalúa la expresión, si es falsa, se finaliza la sentencia. Si es verdadera se ejecuta el bloque, se ejecuta el bloque final y se vuelve a evaluar la expresión.





Sintaxis:

      for( inicial;

             expresion;

             final)

        bloque

En esta estructura puede omitirse cualquiera de los tres campos, pero es impresindible mantener los ";". Si se omite el segundo campo, la condición se da por cierta, y se obtiene un bucle infinito.  

• Estructuras anidadas

Se puede colocar instrucciones de control dentro de otras instrucciones de control, por ejemplo un bloque if else dentro de un bucle for cuando una estructura de control se coloca dentro de otra estructura de control, se dice que se está anidando.

     for( inicial; expresion; final)

     {
       if (expresion)
         sentencia
       else
         sentencia
     }     

Ejemplos:

• Estructura selectiva doble: if else

#include <stdio.h>

/* Programa que calcula si un año es bisiesto o no*/

int main()

{

   int year = 0;

   printf("Introduzca un anio: ");

   scanf("%d", &year);

   if((0 == year %400) || ((0 == year % 4) && (0 != year % 100)))

      printf("El anio %d es bisiesto\n", year);

   else 

      printf("El anio %d no es bisiesto\n", year);

   return 0;

}

• Estructura selectiva multiple: if else

#include <stdio.h>

/* Programa que lea un número del mes (en el rango de 1 a 12) e indique el número de días que tiene el mes*/

int main()

{

  int mes = 0;

  int ndias = 0;

  printf("Introduzca el número de un mes  (1-12): ");

  scanf("%2d", &mes);

  switch(mes)

  {

     case 2: 

             ndias = 28;

             break;

     case 4:

     case 6:

     case 9:

     case 11:

             ndias = 30;

             break;

     default:

             ndias = 31;

             break;

  }

  

  printf("El mes %d tiene %d dias.\n", mes, ndias);

  return 0;

}

• Estructura repetitiva: while

#include <stdio.h>

/* Programa que hace una suma de 1 hasta 10*/

int main()

{

  int sumatoria = 0;

  int contador = 0;

  while(contador < 10)

  {

    contador++;

    sumatoria += contador;

  }

  printf("La sumatoria de 1 hasta 10 es: %d", sumatoria);

  

  return 0;

}

• Estructura selectiva multiple: for

#include <stdio.h>

/*Programa que obtiene la suma de los números pares comprendidos entre 2 y 1000*/

int main()

{

   int i;

   int suma = 0;

   for( i = 2; i <= 1000; i += 2 )

       suma += i;

   printf("La suma de los pares hasta 1000 es: %d", suma);

   return 0;

}