PDF de programación - Estructuras Cíclicas

Programación Instituto Tecnológico de Celaya

EESSTTRRUUCCTTUURRAASS CCÍÍCCLLIICCAASS

Se discuten en este documento las sentencias que se utilizan en el lenguaje

C++ para representar

la tercera de

las estructuras utilizadas en

la

programación estructurada: La Estructura Repetitiva o Iterativa.


Sentencias de Procesamiento Iterativo: while y do-while
En muchos programas será necesario ejecutar acciones en forma repetitiva.

Una parte de un programa que repite una sentencia o un grupo de sentencias

se denomina ciclo. El lenguaje C++ tiene varias formas de representar ciclos.

Una de estas formas es a través de la sentencia while (o ciclo while). Antes de

crear el programa C++ para un ejemplo de relevancia, analicemos el siguiente

ejemplo:


#include <iostream.h>
#include <stdlib.h>

int main()
{
/* Este programa es un ejemplo de la utilización de
las sentencias repetitivas while */

int conteo;

cout<< "Cuantas veces deseas que te diga Hola? \n";
cin>>conteo;

while (conteo > 0)
{
cout<<"Hola ";
conteo = conteo – 1 ;
}

cout<< " \n";
cout<< "Es todo \n";

system("PAUSE");
return 0;
}


Ingeniería Química

Programación Instituto Tecnológico de Celaya

La parte del programa que se encuentra en negritas y en mayor tamaño es un

ejemplo de uso de la sentencia repetitiva while. La traducción de while en

español es mientras. Por ello, la sentencia:

while (conteo > 0)
{
cout<<"Hola ";
conteo = conteo – 1 ;
}
puede entenderse como “mientras conteo sea mayor a cero, ejecuta las

sentencias entre llaves”.

Observe que luego de la palabra while se encuentra una comparación

(expresión booleana) entre paréntesis. Por otra parte, hay una conjunto de

sentencias que se encuentran encerradas entre llaves. A dicho grupo de

sentencias se le conoce como el cuerpo de la sentencia while. Las sentencias

entre llaves se repiten mientras la expresión booleana tenga el valor de

verdadero. A cada repetición del ciclo se le conoce como iteración. Las

sentencias entre llaves se ejecutan en el orden en que se escriben.


Observe tres casos de lo que se mostraría en pantalla con la ejecución de este

programa:


Corrida 1:
Cuantas veces deseas que te diga Hola?
3
Hola Hola Hola
Es todo
Presiona cualquier tecla para continuar...

Corrida 2:
Cuantas veces deseas que te diga Hola?
1
Hola
Es todo
Presiona cualquier tecla para continuar...

Corrida 3:
Cuantas veces deseas que te diga Hola?
0

Es todo
Presiona cualquier tecla para continuar...

Ingeniería Química

Programación Instituto Tecnológico de Celaya

Analicemos el caso de la Corrida 1. Luego del mensaje:

Cuantas veces deseas que te diga Hola?

El usuario teclea el número 3 que, a través de la instrucción cin se le asigna a la

variable conteo. Inicia entonces el ciclo repetitivo. Cuando una sentencia while

se ejecuta, lo primero que se realiza es que se evalúa el valor de verdad de la

expresión entre paréntesis (conteo>0). Observe que al principio la variable

conteo vale 3, por lo que conteo>0 da como resultado el valor verdadero.

Debido a que el valor de dicha expresión es verdadero, se ejecutarán las

sentencias del cuerpo de la sentencia while (entre llaves):


cout<<"Hola ";
conteo = conteo – 1 ;

Por esta razón se imprimirá en pantalla la palabra Hola por primera vez. Luego

de ello la el valor de la variable conteo se reduce en uno. Su valor cambia de 3

a 2:

conteo = 3 – 1 = 2


Con la llave } de la sentencia while se termina la primera iteración y comienza

la siguiente. Nuevamente, lo primero que se hace es que se evalúa la expresión

booleana. Dado que ahora la variable conteo vale 2, la expresión conteo>0

sigue siendo verdadera y nuevamente se ejecutan las sentencias entre llaves.

Por ello se mostrará nuevamente la palabra Hola y otra vez la variable conteo

reduce su valor en uno:

conteo = 2 – 1 = 1

El procedimiento continúa en la misma forma hasta que, después de la tercera

iteración, la variable conteo vale cero. Cuando esto ocurre, la expresión

conteo>0 ya tiene el valor de falso y por tanto las sentencias entre llaves ya no

se ejecutarán por cuarta vez.

En general, la sintaxis de una sentencia while es la siguiente.


Una sola sentencia en el ciclo:
while (expresion_booleana)
sentencia_del_ciclo;

Ingeniería Química

Programación Instituto Tecnológico de Celaya

Cuando se tienen más de una sentencia en el ciclo:
while (expresion_booleana)

{

sentencia_1_del_ciclo;

sentencia_2_del_ciclo;
∶
ultima_sentencia_del_ciclo;

}


Observe que las líneas correspondientes a while y a las llaves no llevan punto

y coma.

Existe una forma equivalente de expresar la sentencia while. Esto es a través de

la sentencia do-while. La sintaxis de la sentencia do-while es como sigue:


Una sola sentencia en el ciclo:
do

sentencia_del_ciclo;

while (expresion_booleana);


Cuando se tienen más de una sentencia en el ciclo:
do

{

sentencia_1_del_ciclo;

sentencia_2_del_ciclo;
∶
ultima_sentencia_del_ciclo;

} while (expresion_booleana);


Observe que la sentencia do-while termina con punto y coma luego de la

expresión booleana.

Ingeniería Química

Programación Instituto Tecnológico de Celaya

Es decir, es lo mismo escribir:


while (conteo > 0)
{
cout<<"Hola ";
conteo = conteo – 1 ;
}


que escribir:

do
{
cout<<"Hola ";
conteo = conteo – 1 ;
} while (conteo > 0);


Ejemplo: Cálculo del Factorial de un Número Entero
Anteriormente se analizó el diagrama de flujo para determinar el factorial de un

número entero. Dicho diagrama de flujo se muestra en la página siguiente.

Observe que un conjunto de instrucciones del diagrama de flujo se realizan en

forma repetitiva mientras se satisface una condición. En este caso la condición

es contador<numero. Es decir, mientras contador<numero, se ejecutarán las

asignaciones:


factorial = factorial * contador;

contador = contador + 1;

El programa en C++ correspondiente a este diagrama de flujo es:

#include <iostream.h>
#include <stdlib.h>

int main()
{
/* Este programa permite el calculo del factorial de un numero entero */

int numero, factorial contador;

cout<< "Dame un numero entero \n";
cin>>numero;

factorial = 1;

Ingeniería Química

Programación Instituto Tecnológico de Celaya

contador = 1;

while (contador <= numero)
{
factorial = factorial * contador;
contador = contador + 1 ;
}
cout<<”El factorial de ”<< numero<< “ es ”<<factorial << "\n";

system("PAUSE");
return 0;
}



Inicio

numero

factorial = 1

contador = 1

Falso

contador < numero

Verdadero

factorial=factorial * contador

contador=contador + 1

factorial

Fin



Ingeniería Química

Programación Instituto Tecnológico de Celaya

Nota Importante acerca de while y do-while
Es importante mencionar que con la sentencia do-while, las sentencias del ciclo

se ejecutan por lo menos una vez, mientras que en la sentencia while las

sentencias del ciclo pudieran no ser ejecutadas ni una sola vez, dependiendo de

la expresión boleana. Es decir, cuando se ejecuta una sentencia do-while, la

primera vez se ejecutan las sentencias del cuerpo de la sentencia y es hasta

entonces que se evalúa la expresión boleana. El ciclo se repetirá sólo si la

expresión boleana sigue teniendo el valor de verdadero. Por otro lado, en la

sentencia while, aún la primera vez, lo primero que se evalúa es la expresión

boleana y sólo si ésta es verdadera las sentencias del ciclo se ejecutarán. En

otras palabras, las sentencias while y do-while son equivalentes sólo si el ciclo

se ejecuta al menos una vez.


Operadores de Incremento y Decremento
Hasta ahora, los operadores aritméticos que se han estudiado (+, -, *, /)

involucran dos operandos. Por ejemplo a+b, x*y, etc. Por ello, a dichos

operadores se le conocen como operadores binarios. Se introducen aquí los

operadores conocidos como operadores unarios. Los más comunes se

representan como ++ (operador incremental) y –- (operador decremental).

Estos operadores se aplican sobre una sola variable y se aplican sobre

variables enteras. El operador ++ incrementa el valor de una variable en uno.

Mientras que el operador –- disminuye el valor de una variable en uno.

Por ejemplo:


n++;

m--;


Son sentencias ejecutables de C++. La primera sentencia hace que el valor de

n aumente en uno