docoo
Sentencias de control
Las sentencias de control pueden ser:
  1. Bifurcaciones.
  2. Saltos.
  3. Loop. Bucle.
    1. if
                          if (condicion ) /* si condicion es 0 se ejecuta el siguiente paquete de sentencias en caso contrario  se salta */
                          {
                              sent_1;
                              sent_2;
                              sent_3;
                              ....
                          }
                      
      if else
                          if (condicion ) /* si condicion es 0 se ejecuta el siguiente paquete de sentencias en caso contrario  se salta */
                          {
                              sent_1;
                              sent_2;
                              sent_3;
                              ....
                          }
                          else  /* si la condicion es distinta de 0 se ejecuta este  paquete */
                          {
                              sent_a;
                              sent_b;
                              sent_c;
                              ....
                          }
                      

      Se pueden omitir las llaves { } si solo hay una sentencia.

      Se consiente la anidación en cualquiera de estos bloques.

      En el if-else no se ejecutan nunca los dos bloques.

    2. switch
                          switch (expresión)
      
                          {
                              case n1: /* Si las expresion coincide con n1 entonces se ejecuta desde aquí en adelante hasta encontar un break; que lo expulse de switch */
                              sents_1
                              break:
      
                              case n2: /* Si las expresion coincide con n2 entonces se ejecuta desde aquí en adelante hasta encontar un break; que lo expulse de switch */
                              sents_2
                              break:
      
                              case n3: /* Si las expresion coincide con n3 entonces se ejecuta desde aquí en adelante hasta encontar un break; que lo expulse de switch */
                              sents_3
                              break:
      
                              .......
      
                              default: /* Si no se ha ejecutado ninguno se ejecuta el default este no necesita break por ser el último. */
                              sents_def;
      
                          }
      
                      

      Cuando se ejecuta un switch se compara con el resto de los case de forma ordenada hasta que uno cumple , a partir de ahí se ejecutan las siguientes sentencias hasta encontar un break; (con independencia de los siguientes cases) , los cases solo son una marca de donde acceder al paquete de sentencias.

      El default es opcional, pero de no ponerse puede pasar por el switch sin ejecutar ninguna sentencia.

    3. ?:

      Es una sentencia if else

       a = exp ? exp_v : exp_f 

      A puede tomar dos valores que dependen de exp , si exp es verdadera entonces a vale exp_v y si es falsa exp_f.

    Loop, Bucle
    • for
                              for(inicio; condicion; incremento){
                                  sent_1;
                                  sent_2;
                                  ....
                              }
                          

      inicio se ejecuta 1 vez al principio y se pueden iniciar varias sentencias.

      condicion se ejecuta cada vez que va ha hacer el paquete de sentencias, si es distinta de 0 las ejecuta.

      incremento se ejecuta cada vez que termina el paquete de sentencias , puede contener varias sentencias separadas por ",".

    • while
                              while(condicion){
                                  sent_1;
                                  sent_2;
                                  ....
                              }
                          

      Se realiza condición si el resultado es distinto de 0 se ejecuta el paquete de sentencias y vuelve a realizar la condición hasta que se deje de cumplir y se salga del bucle.

    • Do while
                              do{
                                  sent_1;
                                  sent_2;
                                  ....
                              }while(condicion);
                          

      Se realiza el paquete de sentencias, se realiza la condición hasta que se deje de cumplir y se salga del bucle.

      La diferencia con el do es que aquí siempre se entra por lo menos una vez en el bucle.

    • En los loop también es normal encontar el control por flag , bandera , o variable externa que consiste en utilizar una tercera variable para poder escapar o seguir en el bucle.

  1. Sentencia de salto

    goto
                goto etiqueta
                .....
                etiqueta:
                    sent_1
                ....
            

    Cada vez que se ejecute goto etiqueta , se ira a la marca de la posición etiqueta y comenzara a ejecutar las siguientes sentencias.

    La etiqueta no se puede repetir dentro de la misma función.

    Se considera un mal modo de programar en C , pero está ahí.

    Es una herencia de los lenguajes de ensamblador.

--