C++ : Practica 7: Las Declaraciones y el Control de Flujo en C++

Una declaración simple de C ++ es cada una de las instrucciones individuales que se hacen en un programa, como aquellas declaraciones de variables y expresiones que se vieron en capítulos anteriores. Siempre terminan con un punto y coma (;) y son ejecutadas en el mismo orden en que aparecen dentro del programa. Pero los programas no se limitan a una secuencia lineal de enunciados. Durante su proceso, un programa puede repetir segmentos de código, tomar decisiones y dividirse. Justamente para ese propósito C ++ proporciona instrucciones de control de flujo, que sirven para especificar lo que debe hacer nuestro programa, cuándo y bajo qué circunstancias. Las instrucciones pueden ser de dos tipos: Instrucción Simple cuando es compuesta por una sola instrucción terminada con punto y coma (;) o una instrucción compuesta cuando es determinada por un grupo de enunciados (cada uno de ellos terminado por su propio punto y coma), pero todos agrupados en un bloque, encerrados entre llaves: "{ }"; algo así:

{ instruccion1; instruccion2; instruccion3; } 

Todo el bloque se considera una sola instrucción (compuesta de múltiples sub-instrucciones).

Instrucciones de Condición: if y else

La palabra clave if se usa para ejecutar una instrucción o bloque, si, y solo si, se cumple una condición. Su sintaxis es:

if (condicion) instruccion

Aquí, la condicion es la expresión que se está evaluando. Si esta condicion es verdadera, la instruccion se ejecuta y en caso sea falsa, la instruccion no se ejecuta (simplemente se ignora) y el programa continúa justo después de la Instruccion de Condición. Por ejemplo, el siguiente fragmento de código imprime el mensaje "x es 100", sí y sólo si el valor almacenado en la variable x es de hecho 100:

if (x == 100)
 cout << "x es 100";

En este ejemplo, si x no es exactamente 100, la afirmación se ignora y no se imprime nada. Si desea incluir más de una declaración para que se ejecute cuando se cumpla la condición, estas declaraciones se incluirán dentro de llaves ({}) formando un bloque, veamos un ejemplo:

if(x==100)
{
    cout << "x es ";
    cout << x;
}

Veamos esto en la práctica!:

Las sentencias con la instrucción if también pueden especificar qué sucede cuando la condición no se cumple, usando la palabra clave else para introducir una sentencia alternativa. Su sintaxis es:

if (condicion) instruccion1 else instruccion2

donde declaracion1 se ejecuta en caso de que la condición sea verdadera, y en caso de que no lo sea, se ejecuta declaracion2. Para ver este caso, veamos un ejemplo:

if (x == 100)
   cout << "x es 100";
else
cout << "x no es 100";

Esto debería imprimir x es 100, si de hecho x tiene un valor de 100, pero si no es así, y solo si no lo es, imprime x no es 100 en su lugar. Veamos esto con un ejemplo:

Várias estructuras if else pueden concatenarse con la intención de verificar un rango de valores. Veamos:

if (x > 0)
   cout << "x es positivo";
else if (x < 0)
   cout << "x es negativo";
else 
   cout << "x es 0";

Esto imprime x es positivo, negativo o cero al concatenar dos estructuras if-else.De nuevo, también habría sido posible ejecutar más de una declaración individual agrupándolos en bloques entre llaves: {}. En la práctica:

[tab] [content title="Uso de If"] [/content] [/tab] [tab] [content title="Uso de if/else"] [/content] [/tab] [tab] [content title="Uso de if/else mejorado"] [/content] [/tab]

Sentencias de Iteración (loops ó Bucles)

Los bucles Loops repiten una declaración un cierto número de veces, o mientras se cumple una condición.

El Loop Bucle While

El tipo más simple de bucle Loop es el bucle While. Su sintaxis es:

while (expression) statement

El loop bucle while simplemente repite la instrucción mientras que la expresión es verdadera. Si después de cualquier ejecución del enunciado, la expresión ya no es verdadera, el ciclo finaliza y el programa continúa justo después del ciclo. Por ejemplo, echemos un vistazo a una cuenta regresiva usando un bucle loop while:

//Declaraciones y controles de flujo
#include <iostream>
using namespace std;

int main()
{
    int n = 10;
    while(n > 0)
    {
        cout << n << ",";
        --n;
    }
    cout << "despegue!\n";
}

La primera instrucción en main establece en n un valor de 10. Este es el primer número en la cuenta regresiva. Luego comienza el ciclo while: si este valor cumple la condición n > 0 (que n es mayor que cero), el bloque que sigue a la condición se ejecuta y se repite mientras la condición (n >  0) permanezca siendo cierto.Todo el proceso del programa anterior se puede interpretar de acuerdo con el siguiente guión (comenzando en el principal):

1. n tiene asignado un valor,
2. La condición de tiempo esta marcada (n > 0). En este punto hay dos posibilidades:
• La condición es verdadera: La instrucción se ejecuta y vamos al paso 3
• La condición es falsa: se ignora la instrucción y el programa continua a desarrollarse después de ella; o sea nos vamos al paso 5.
3. Se ejecuta la declaración:   

   cout << n << ", ";
       --n; 

   (se imprime el valor de n y se disminuye n en 1)
4. Fin del bloque. Se regresa automáticamente al paso 2.
5. Continua el programa justo después del bloque. Se imprime despegue! y termina el programa.

Una cosa a considerar utilizando el loop while es que el ciclo debe finalizar en algún punto y por lo tanto el enunciado se deberá modificar en su condición de alguna manera para forzar a que este se vuelva falso en algún momento; de lo contrario, el bucle loop continuará dando vueltas para siempre!. 

En este ejemplo anterior, el bucle incluye --n, que disminuye el valor de la variable n de uno en uno; esto eventualmente hará que la condición (n > 0 ) sea falsa después de un cierto número de iteraciones del loop bucle.

Para ser más específico, después de 10 iteraciones, n se convierte en 0, haciendo que la condición ya no sea verdadera y acabe por dar por terminado el ciclo while.

Tenga en cuenta que la complejidad de este bucle es de total conocimiento para una computadora, por lo que la cuenta regresiva se realiza instantaneamente, sin ningún retraso entre los elementos del conteo (si quiere aprofundarse más, consulte sleep_for para mayores referencias en este asunto). 

El Loop Bucle do-while

Un bucle muy similar es el bucle do-while, cuya sintaxis es:

do declaracion while (condicion);

Este loop bucle se comporta como un ciclo while, excepto que la condición se evalúa después de la ejecución de la instrucción en lugar de antes, garantizando al menos una ejecución de la instrucción, incluso si la condición nunca se cumple. Por ejemplo, el siguiente programa de ejemplo hace eco de cualquier texto que el usuario introduzca hasta que el usuario se despida:

//Declaraciones y controles de flujo
#include <iostream>
#include <string>
using namespace std;

int main()
{
    string str;
    do {
        cout << "Ingrese un texto: ";
        getline (cin, str);
        cout << "Usted ha ingresado: " << str << '\n';
    } while (str != "goobye");
}

Generalmente se prefiere el bucle do-while sobre un bucle while siempre y cuando la sentencia deba ejecutarse al menos una vez, como por ejemplo cuando la condición que se verifica al final del bucle se determina dentro de la declaración. En el ejemplo anterior, la entrada del usuario dentro del bloque es lo que determinará si el ciclo finaliza.Y así, incluso si el usuario desea finalizar el ciclo lo antes posible al ingresar adiós, el bloque en el ciclo debe ejecutarse al menos una vez para solicitar la entrada, y la condición puede, de hecho, solo determinarse después que es ejecutada.

El Loop Bucle for

El bucle for está diseñado para iterar varias veces. Su sintaxis es:

for (inicializacion; condicion; incremento) declaracion;

Al igual que el ciclo while, este ciclo repite la instrucción mientras que la condición sea verdadera. Pero, además, el bucle for proporciona ubicaciones específicas donde puede contener una inicialización y una expresión de incremento, ejecutada antes de que el bucle comience por primera vez, y después de cada iteración, respectivamente. 

Por lo tanto, es especialmente útil usar variables de contador como condición.

Funciona de la siguiente manera:

1. La inicialización se ejecuta. En general, esto declara una variable de contador y establece un valor inicial. Esta se ejecuta una sola vez, al comienzo del ciclo.
2. La condición es evaluada y checada. Si esta es verdadera, el ciclo continua, de lo contrario el ciclo finaliza y y la declaracion es omitida, yendo entonces directamente al paso 5. 
3. declaracion es ejecutada. Como de costumbre, puede ser una sola declaracion ó un bloque encerrado entre llaves.
4. Se ejecuta el incremento y el ciclo vuelve al paso 2.
5. El ciclo termina: la ejecución continúa con la siguiente instrucción después de ella.

Aquí ejemplificamos el ejemplo de cuenta regresiva utilizando el bucle loop for:

//Declaraciones y controles de flujo
#include <iostream>
using namespace std;

int main()
{
    for (int n = 10; n > 0; n--)
    {
        cout << n << ", ";
    }
    cout << "Despegue!\n";
}

Los tres campos en un bucle for son opcionales. Se pueden dejar vacíos, pero en todos los casos se requieren signos de punto y coma entre ellos. 

Por ejemplo, para (; n <10;) es un bucle sin inicialización o aumento (equivalente a un bucle while); y para (; n <10; ++ n) es un ciclo con incremento, pero sin inicialización (tal vez porque la variable ya se había inicializado antes del ciclo). Un bucle sin condición es equivalente a un bucle con una condición verdadera (es decir, un bucle infinito).

Debido a que cada uno de los campos se ejecuta en un momento particular del ciclo de vida de un bucle, puede resultar útil ejecutar más de una expresión individual como cualquiera de inicialización, condición o declaración. Desafortunadamente, estas no son declaraciones y tampoco expresiones simples, por lo tanto no pueden ser reemplazadas por un bloque.  Como expresiones, pueden sin embargo hacer uso del operador de coma (,): este operador es un separador de expresiones y puede separar múltiples expresiones donde generalmente solo se espera una.

Por ejemplo, al usarla, sería posible que un bucle for maneje dos variables de contador, inicializando y aumentando ambas, tipo esto:

for (n=0, i=100; n!=i; ++n,--i )
{
   //cualquier cosa aquí!
}

Este ciclo se ejecutará 50 veces si ni n ni i se modifican dentro del ciclo:

n comienza con un valor de 0,  y i con 100, la condición es n != i (es decir, que n no es igual a i). Como n aumenta en uno, y i disminuye en uno en cada iteración, la condición del ciclo se volverá falsa después de la iteración 50, cuando tanto n como i sean iguales a 50. [tab] [content title="Ejemplo 1"] Escribir en pantalla los números del 1 al 10 con el ciclo for

//contar del 1 al 10 con for
#include <iostream>
using namespace std;

int main()
{
    int x;
    for (x = 1; x <= 10; x++)
        cout << x << "\n";
    return 0;
}

[/content] [content title="Ejemplo 2"] Escribir los números del 1 al 10 comenzando por el número que el usuário indique

//contar del numero que se ingrese al 10 con for
#include <iostream>
using namespace std;

int main()
{
    int x;
    int numero; //numero igresado por el usuário
    cout << "Ingrese un número menor que 10:";
    cin >> numero;
    for (x = numero;x <= 10; x++)
        cout << x << "\n";
    return 0;
}

[/content] [content title="Ejemplo 3"] En este conteo todo comenzará en el 1 y terminará en el numero que el usuario ingrese!

//contar del numero que se ingrese al 10 con for
#include <iostream>
using namespace std;

int main()
{
    int x;
    int numero; //numero igresado por el usuário
    cout << "Ingrese un número menor que 10:";
    cin >> numero;
    for (x = numero;x <= 10; x++)
        cout << x << "\n";
    return 0;
}

[/content] [/tab]

Rango para el Loop Bucle For

El bucle Loop for tiene otra sintaxis, que se usa exclusivamente con rangos:

for ( declaracion : range ) sentencia;

Este tipo de bucle for itera sobre todos los elementos en el rango, donde declaracion declara alguna variable capaz de tomar el valor de un elemento en este rango. Los rangos son secuencias de elementos, que incluyen matrices, contenedores y cualquier otro tipo que soporte las funciones de inicio y fin; la mayoría de estos tipos aún no se han introducido en este tutorial, pero ya estamos familiarizados con al menos un tipo de rango: cadenas ó srtrings, que son secuencias de caracteres.

Ejemplifiquemos esto:

//Declaraciones y controles de flujo
#include <iostream>
#include <string>
using namespace std;

int main()
{
    string str {"Hello"};
    for (char c: str)
    {
        cout << "[" << c << "]";
    }
    cout << '\n';
}

Observe que lo que precede a los dos puntos (:) en el ciclo for es la declaración de una variable char (los elementos en una cadena son de tipo char). Luego usamos la variable c en el bloque de enunciados para representar el valor de cada uno de los elementos en el rango.

Este ciclo es automático y no requiere la declaración explícita de ninguna variable de contador. Los bucles basados en rangos generalmente también usan la deducción de tipo para el tipo de elementos con auto. Normalmente, el ciclo anterior de rango también se puede escribir como:

for (auto c : str)
   cout << "[" << c << "]";

Aquí, el tipo de c se deduce automáticamente como el tipo de elementos en str.

Saltos en Declaraciones

Los saltos en las declaraciones permiten alterar el flujo de un programa al realizar saltos a ubicaciones específicas.

Declaración de interrupción Break

La declaración de interrupción break quiebra el ciclo de un bucle loop, incluso si la condición para su final no se cumple. Se puede usar para finalizar un ciclo infinito o para forzarlo a terminar antes de su final natural. Por ejemplo, detengamos la cuenta atrás antes de su final natural:

//Ejemplo de Break en bucle:
#include <iostream>
using namespace std;

int main()
{
    for (int n = 10; n > 0; n--)
    {
        cout << n << ",";
        if (n == 3)
        {
            cout << " cuenta abortada!";
            break;
        }
    }
}

Declaración de Interrupción

Declaración continue

La instrucción continue hace que el programa saltee el resto del ciclo en la iteración actual, como si se hubiera alcanzado el final del bloque de instrucciones, haciendo que salte al comienzo de la siguiente iteración. 

Por ejemplo, salteemos el número 5 en nuestra cuenta atrás:

//Ejemplo de continue en bucles loop
#include <iostream>
using namespace std;

int main()
{
    for(int n = 10; n > 0; n--)
    {
        if (n == 5) continue;
        cout << n << ", ";
    }
    cout << "despegue!\n";
}

Declaración goto

goto permite realizar un salto absoluto a otro punto en el programa. Este salto incondicional ignora los niveles de anidación y no causa ningun avanza automático de la pila. Por lo tanto, es una característica para usar con cuidado, y se recomienda dentro del mismo bloque de decisiones, especialmente en la presencia de variables locales.El punto de destino se identifica mediante la etiqueta ó label, que se utiliza entonces como un argumento para la declaración de goto. La etiqueta label está hecha de un identificador de identidad seguido de la colon (:).

El goto es una combinación de la característica de bajo nivel, con el uso de casos particulares en los sistemas de planificación de parámetros de alto nivel, de niveles de uso común con C ++. Pero, justo como un ejemplo, aquí esta la nueva version de nuestro cuenta de tiempo de bucle usando goto:

//Ejemplo de goto en bucles loop
#include <iostream>
using namespace std;

int main()
{
    int n = 10;
milabel:
    cout << n << ", ";
    n--;
    if (n > 0) goto milabel;
    cout << "despegue!\n";
}

Sentencia de Condición: switch

La sintaxis de la instrucción switch es un bit peculiar. Su propósito es comprobar un valor entre un número de posibles declaraciones. Es algo similar a la concatenación de declaraciones con if-else, pero limitado a constantes expresiones. 

Su sintaxis más típica es:

switch (expression)
{
  case constante1;
    grupo-de-declaraciones-1;
    break;
  case constante2;
    grupo-de-declaraciones-2;
    break;
  .
  .
  .
  default:
    default-grupo-de-declaraciones 
}

Funciona de la siguiente manera: 

switch evalúa la expresión y comprueba si es equivalente a constante1; si es así, ejecuta grupo-de-declaraciones-1 hasta que encuentre la sentencia break. Cuando encuentra esta declaración de interrupción, el programa salta al final de toda la instrucción de conmutación (la llave de cierre).Si la expresión no era igual a constante1, entonces se compara con constante2. Si es igual a esto, ejecuta grupo-de-declaraciones-2 hasta que se encuentre un corte break, entonces salta al final de switch.

Finalmente, si el valor de expresión no coincide con ninguna de las constantes previamente especificadas (puede haber un número de ellas), el programa ejecuta las instrucciones incluidas después de la etiqueta default: si existiese (dado que es opcional).

Los dos fragmentos de código siguientes tienen el mismo comportamiento, lo que demuestra el equivalente if-else de una instrucción switch:

La sentencia switch tiene una sintaxis algo peculiar, esta es heredada de los primeros compiladores de C, ya que utiliza etiquetas en lugar de bloques. En el uso más típico (mostrado arriba), esto significa que las declaraciones de interrupción son necesarias después de cada grupo de declaraciones para una etiqueta en particular. Si no se incluye el salto, todas las instrucciones que siguen al caso (incluidas las que están debajo de cualquier otra etiqueta) también se ejecutan, hasta que se alcanza el final del bloque de cambio o una declaración de salto (como un break).

Si el ejemplo anterior careciera de la declaración de interrupción break después del primer grupo para el caso uno, el programa no saltaría automáticamente al final del bloque switch después de imprimir "x es 1" y en su lugar continuaría ejecutando las declaraciones en el caso dos (imprimiendo también x es 2). Luego continuaría haciéndolo hasta que se encuentre una declaración de interrupción o el final del bloque de conmutación. Esto hace innecesario encerrar las declaraciones para cada caso entre llaves {}, y también puede ser útil para ejecutar el mismo grupo de declaraciones para diferentes valores posibles. Veamos un ejemplo:

switch(x){
  case 1:
  case 2:
  case 3:
    cout << "x es 1, 2 ó 3";
    break;
  default:
    cout << "x no es 1, 2 ó 3";
}

Observe que el switch se limita a comparar su expresión evaluada con las etiquetas labels que son expresiones constantes. No es posible usar variables como etiquetas o rangos, porque no son expresiones constantes válidas de C ++. Para comprobar los rangos o valores que no son constantes, es mejor utilizar concatenaciones de if y otras declaraciones.

[tab] [content title="Uso de Switch"] [/content] [/tab]

Hasta este momento hemos aprendido la base de lo que es la programación en C++; un cimiento bastante fuerte para quien quiere comenzar a programar. Eso sí; no crean que esto es todo. Ahora es necesario practicar para no quedar en el camino!.