Capitulo 4. Sentencias Repetitivas

Fuente:

Programación en C++ / Principios y Aplicaciones (resumen)

Carlos Romero Shollande

1. Introducción

Las sentencias repetitivas permiten que, dado un conjunto de sentencias, la computadora las repita, formando bucles o ciclos, hasta que se cumpla con cierta condición.

La condición puede estar ubicada ya sea en la parte superior del bucle, como en la parte inferior del mismo.

1.1. Operadores de Repetición

Tabla 1. Operadores de repetición

OPERADOR

ACCIÓN

- - ++ += -= *= /= %=

Decremento de una unidad al contenido de la variable Incremento de una unidad al contenido de la variable Suma al contenido de la primera variable, el contenido de la segunda. Ejemplo: x += 2. Aumenta el valor de x en 2 Resta al contenido de la primera variable, el contenido de la segunda. Ejemplo: x - = 5. Disminuye x en 5 Multiplica al contenido de la primera variable, el contenido de la segunda. Ejemplo: x * = 3. Multiplica el valor de x por 3 en cada oportunidad Divide al contenido de la primera variable, el contenido de la segunda. Ejemplo: x / = 4. Divide el valor de x entre 4 en cada oportunidad Determina el resto de la primera variable entre la segunda. Ejemplo: w%=9; Esto es similar a w = w%9;

x ++  es lo mismo que:  x = x + 1

x - -  es lo mismo que:  x = x – 1

Si se pone un operador ++ o -- antes de la variable, se le llama operador de preincremento o predecremento respectivamente. Ejemplo:

x =10;  y = ++x;

El resultado es y = 11 por que primero se incrementa x, y después lo asigna a y.

Si se coloca después de la variable, se le llama operador de posincremento o posdecremento respectivamente. Ejemplo:

x = 10;  y = x++;

El resultado es y = 10 y después incrementa en 1 a y 

1.2. Precedencia de operadores 

Tabla 2. Precedencia de operadores

ORDEN	OPERADOR	ASOCIATIVIDAD	TIPO	OBSERVACION
1 2 3 4 5 6 7 8 9 10	(   ) ++    --    +    - *    /    % +    - <<    >> <    <=    >    >= ==    != ?: =   +=   -=   *=   /=   %= ,	Izquierda a derecha Derecha a izquierda Izquierda a derecha Izquierda a derecha Izquierda a derecha Izquierda a derecha Izquierda a derecha Derecha a izquierda Derecha a izquierda Izquierda a derecha	Paréntesis Unario Multiplicativo Aditivo Inserción/extracción Relacional Igualdad Condicional Asignación Coma	Más alto Más bajo

2. Inicialización de Variables

Sintaxis     :  tipo nombre_variable = constante;

Propósito  :  Establecer el valor inicial de una variable a la vez que se declaran poniendo un signo igual y una constante después del nombre de la variable.

Ejemplo   :  int j = 5;

                 char w = ‘g’;

En la primera sentencia se coloca la constante entera (5) como primer valor de la variable de control de bucles o contador (j) y en la segunda se coloca la constante de tipo carácter (g) como valor inicial de la variable (w).

3. Sentencia Repetitiva con Condición al Inicio del Bucle

Sintaxis     :  while (condición) sentencias;

Propósito  :  Repetir el bucle mientras la condición, que se encuentra al inicio, sea verdadera (TRUE).

Gráfica 1.  Sentencia Mientras

Cuando llega a ser falsa (FALSE), el control del programa pasa a la línea que sigue al bucle.

Ejemplo  :  while (t!=5)  {

                 cout<<t;

                 t=t+1;

                 }

En el ejemplo, la sentencia while comprueba primero si la variable t es diferente que 5, mientras sea así ejecutará las sentencias que se encuentran dentro del bloque, las mismas que reportan el valor de t y luego incrementan su valor en 1.

Cuando t llegue a ser 5 el bucle terminará.

3.1. Repetición Controlada por Contador

Es una técnica que emplea una variable llamada contador que controla el número de veces que se ejecutará un grupo de sentencias y se la conoce como “repetición definida”, debido a que antes de iniciar la ejecución del ciclo ya se conoce la cantidad de repeticiones. Un bucle controlado por contador consta de tres partes:

- Inicialización de la variable de control de bucle.

- Comprobación del valor final de la variable de control de bucle (es decir, si debe continuar el ciclo).

- Incremento (o decremento) del valor de la variable de control de bucle cada vez que suceda el ciclo.

Ejemplo:

t = 1;                   //  Inicialización de contador

while(t<=10)  {    //  Comprobación

cout<<t<<”\n”;

t=t+1;                   // Incremento

}

Gráfica 2. Control por contador

Primero, al contador t se le asigna un valor inicial igual a 1

Luego while comprueba si el contador t es menor o igual que 10; mientras sea así, ejecutará las sentencias que se encuentran dentro del bucle, las mismas que consisten en reportar el valor de t y luego incrementar su valor en 1.

Cuando t supere el valor 10 el bucle habrá terminado.

3.2. Repetición Controlada por Centinela

Es una técnica que emplea una valor especial llamado centinela que indica el “final de la entrada de datos” y se la conoce como “repetición indefinida”, debido a que la cantidad exacta de repeticiones a realizar no se conoce antes de iniciar la ejecución del ciclo.

El valor elegido como centinela debe ser distinto de los posibles valores que pueda tener la lista de datos, para que se llegue apropiadamente al final de dicha lista.

Ejemplo:
cin>>n;  // Primer valor a ser evaluado

while(n>0)  {

// Un negativo es un valor centinela

cout<<n;

cin>>n;    }

Gráfica 3. Control por centinela.

En el ejemplo, el bucle requiere leer una lista de números positivos, un número negativo se puede utilizar como valor centinela para indicar el final de la lista.

Se requiere ingresar un primer dato a través de una sentencia “cin”, ubicada antes del bucle while, para que el valor de n pueda ser evaluada por la expresión lógica n>0.

Mientras se cumpla con esta condición se ejecutarán las sentencias que se encuentran dentro del bucle, las mismas que consisten en reportar el valor ingresado y luego ingresar un nuevo valor para n.

Si en este ejemplo, después de ingresar varios números positivos ingresamos un número negativo tal como –1, este número se lee pero no se reporta y el bucle terminará

Ejemplo: 

Reportar los números impares de dos cifras. 

Análisis:
En este caso, lo que se quiere es iniciar el conteo por el número 11 (primer impar de dos cifras) y terminar en el número 99 (último impar de dos cifras).

Codificación:

#include <iostream.h>

#include <conio.h>

main()  {

int i=11;                 // Primer impar de dos cifras

while(i<=99)  {       // Limitación del conteo

cout<<i<<endl;       // Reporte

i=i+2;                     // Variación de los números impares

}

getch();

} 

4. Sentencia Repetitiva con Condición al Final del Bucle

Sintaxis   :    do  {       sentencias;   }

                    while (condición);

Propósito :   Repetir el bucle mientras la condición, que se ubica al final del mismo,  sea verdadera.
Esta característica provoca que siempre se ejecute al menos una vez.

Ejemplo  :    do  cin>>q;

                    while(q>100) ;

Gráfica 4. Sentencia Hacer

En este ejemplo, se repetirá el ingreso de un valor para q y al final del bucle se comprobará si dicho valor es mayor que 100, mientras sea así dicho bucle se volverá a repetir.

En caso contrario el bucle terminará.

El uso más común de do/while es en una rutina de selección (en un menú).

Debido a que normalmente se quiere una rutina que se ejecute al menos una sola vez y compruebe una respuesta válida al final del bucle, esto permite avisar al usuario una y otra vez hasta que introduzca una respuesta válida.

Ejemplo: 
Hallar la suma acumulativa de los primeros “n” números naturales.

Análisis:
En este caso, lo que se quiere determinar es lo siguiente:

s = 1 + 2 + 3 + …… + n

Para esto se debe imaginar a la suma acumulativa (s) como un depósito que inicialmente esta vacío (s=0), y que luego, dentro de él se introducirá una cierta sustancia con una capacidad de un litro (i=1). Posteriormente, la capacidad de esta sustancia se incrementará en un litro con respecto a la capacidad anterior (i=i+1), que luego será introducida en el depósito (s=s+i). Este proceso continuará en forma iterativa hasta que la capacidad llegue a “n” litros. 

Codificación: 
#include <iostream.h>     // SUMA ACUMULATIVA

#include <conio.h>

main()  {

int i=1;                           // Contador, se inicia en 1 y en cada ciclo se incrementa en 1

int n;                              // Último número natural de la serie a sumar

int s;                              // Acumulado o suma acumulada

do    {

clrscr();

gotoxy(5,2); cout<<“Ingresar último número de la serie natural: ”;

gotoxy(50,2); cin>>n;    }

while (n <= 0);             // Centinela que garantiza que el número sea positivo

s = 0;                            // Valor acumulado inicialmente por la suma
while(i<=n)   {

s = s + i;                       // Suma acumulativa de los números naturales

i++;

}

gotoxy (5,6); cout << “La suma acumulada es: “<<s;

getch ();

}

5. Sentencia Repetitiva con Número de Bucles Prefijado

Sintaxis     :   for (ini; cond_fin; variac) sentencias;

Propósito  :   Repetir el bucle un numero fijo de veces. Es la sentencia más poderosa y flexible de C++

Ejemplo    :   for (x=0 ; x<=20;

                    x=x+2 ) cout<<x;

Gráfica 5. Sentencia Para

La inicialización (ini) de x es 0.

La condición de finalización (cond_fin) indica que mientras x sea menor o igual que 20 se imprimirá x.

La variación (variac) de x es +2.

Una vez que es falsa, la ejecución del programa seguirá en la sentencia que sigue al for.

El bucle for no siempre necesita ir hacia adelante. Se puede crear un bucle negativo disminuyendo, en vez de incrementando, el valor de la variable de control.

Ejemplo:
for (w=33; w>=9; w=w-3) cout<<w;

Se pueden usar dos o más variables de control del bucle.

int i, j;
for (i=0, j=0; i+j<50; ++i, j++) cout <<i+j;

Este fragmento imprime de 0 a 48 aumentándose en 2.

Las comas que separan las expresiones de inicio y variación significa: “has esto y esto”.

En el bucle for se puede crear un bucle infinito, haciendo las tres expresiones vacías, esto se realiza debido a que la expresión condicional está vacía. Ejemplo:

for ( ; ; ) cout <<”Este bucle funcionará siempre”;

El bucle for no requiere todas las piezas de la definición del bucle; es decir, todas las expresiones son opcionales.

for (g=0; g!=10; ) cin >>g;

La parte de incremento está en blanco. Así, cada vez que g sea diferente que 10 el bucle se repite. Sin embargo, si se escribe 10 en el teclado, el bucle termina.

Con esta sentencia también se pueden crear bucles anidados (cuando un bucle esta dentro de otro)

for (i=1; i<=3; i++)    {

        for (j=1; j<=4; j++)     {

                  k = i*j; cout<<i<<”  ”<<j<<”  “<<k<<”\n”;  } } 

Ejemplo:
Hallar el factorial de un número “n” que sea menor que 15.

Análisis:

El factorial “f” se expresa de la siguiente manera:

f = n! = 1 * 2 * 3 * ….. * n

El procedimiento para determinar el factorial es similar al de la suma acumulativa (problema ilustrativo 1), debe imaginarse al factorial (f) que inicialmente no esta vacío sino que debe ser uno (f=1), y que luego, se multiplicará por un contador cuyo valor inicial es la unidad (i=1). Posteriormente, el contador se incrementará en uno con respecto a su valor anterior (i=i+1), que luego será multiplicado por el factorial (f=f*i). Este proceso continuará en forma iterativa hasta que el contador llegue al valor “n”.

Codificación:

#include <iostream.h>    // FACTORIAL DE UN NUMERO

#include <conio.h>

#include <math.h>

main()    {

float m;                         // Ultimo número de la serie ingresado inicialmente

int i;                              // Contador, se inicia en 1 y en cada ciclo se aumenta en 1

int n;                             // Ultimo número de la serie natural a multiplicar

long int f;                      // Factorial

do    {                           // Garantiza que el número sea un entero no negativo menor que 30

clrscr();

gotoxy(5,3); cout<<“Ingrese un número entero, positivo y menor que 15: ”;

gotoxy(45,3); cin>>m;

}

while (m<=0 || floor(m)!=m || m>15);       // Para que número sea mayor que 15 y positivo

n = (int) m;                                             // Fuerza a que el número sea entero

gotoxy(5,6); cout << “El factorial es: ”;

f = 1;                                                     // Valor asignado inicialmente al factorial

for (i=1; i<=n; i++) f = f * i;                     // Factorial de un número

gotoxy(45,6); cout<<f;

getch();

}

6. Sentencia Incondicional

Sintaxis   :      goto etiqueta;

                      ................

                     etiqueta:

Propósito  :   Remitir el control hacia un lugar remoto del programa, que se define mediante una etiqueta (identificador que va acompañado por dos puntos).

Ejemplo  :     y=8;

                     petróleo:

                     y=y+8 ;  cout<<y;

                     goto petróleo;

Este ejemplo reporta los números enteros múltiplos de 8 hasta el infinito, pues no existe una condición que limite el incremento de la variable y, de ahí el nombre de incondicional.

Programas similares a este, no son recomendables codificar, debido a que puede dañar al sistema.

Esta función no es un elemento necesario para hacer completo el lenguaje.

Sin embargo, el goto es un convenio que, si se usa con cuidado, puede ser beneficioso en ciertas situaciones de programación.

7. Alteración del Control del Flujo

Sintaxis     :   break;

                    continue;

Propósito  :  Cuando se ejecuta break en una estructura, se provoca la salida inmediata de ella y la ejecución del programa continua en la primera sentencia que este después de la estructura.
Mientras que continue al ejecutarse en una estructura, salta las instrucciones restantes del cuerpo de dicha estructura y continua con la siguiente iteración del ciclo.

Ejemplo  :    for (k=0, k<100; k++) {

                        if(k%2==1) continue;  // Salta código faltante      cout<<k;     }

En el ejemplo anterior, cada vez que el programa genera un número impar, la sentencia if se ejecuta, ya que el resto de un número impar entre 2 es igual a 1, lo que hace que la condición sea verdadera.

Así un número impar provoca la ejecución de continue, que provocará que ocurra la siguiente iteración saltando la sentencia cout.

Se puede salir  de un bucle infinito usando la sentencia break, ubicándola en el cuerpo del bucle. Ejemplo:

for (;; )   {

cout <<”Presione 0 para terminar”; cin>>k;

if(k=0) break;    }