Ciclos de Pascal

While: (MIENTRAS – HAGA)

Este ejecuta una serie de instrucciones un número no determinado de veces hasta
que se cumpla con una condición establecida , aunque tambien se puede hacer
que trabaje de manera similar al ciclo FOR.
La instruccion while estudia primero la condicion y, en caso de que se cumpla,
procedera a ejecutar la(s) instruccion(es) deseada(s).
Su estructura es:
while (condicion) do
instruccion;
En caso de que haya mas de una instruccion a realizar, escribiremos:
while (condicion) do
begin
instrucciones;
end;
EJEMPLO:

Program WHILE_a_FOR;
Var I: Integer;
Begin
I := 1; WHILE I <= 4 Do
Begin
WriteLn (`Número ', I);
I := I + 1;
End;
End.

PROGRAM Ciclo_WHILE;
VAR Numero : Integer;
BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN WriteLn (Numero);
Numero := Numero +1;
END;
END.
FOR:(Para – Haga)
Este ciclo ejecuta una serie de instrucciones incrementando
o decrementando una variable hasta un tope determinado .
El ciclo for realiza la(s) instruccion(es) deseada(s) durante un numero de vueltas
predeterminadas. Este numero de vueltas no podra ser modificado NUNCA dentro
del bucle,
por lo que debemos tener cuidado en no tocar la variable indice (la que controla el
numero de vueltas).
Un ejemplo:
program pruebaFor;
CONST
N = 10; { numero de vueltas que dara el bucle}
VAR
i: integer; { variable que contara el numero de vueltas que llevamos}
BEGIN
for i:=1 to N do
writeln(i);
END.
Y se mostraria por pantalla:
1
2
3
4
5
6
7
8
9
10
En caso de que tengamos que ejecutar mas instrucciones dentro del bucle,
escribiriamos:
for (contador) do
BEGIN
instrucciones;
END;
Un ejemplo de esto:
program pruebaForDos;
CONST
N=10;
VAR
i,j : integer; {Una nueva manera de declarar las variables. En caso de tener varias
del mismo tipo,podemos separarlas por ","}
BEGIN
j:=0;
for i:=1 to N do
begin
writeln(i);
j:=j+3; {Con esta instruccion, a la variable j la sumamos durante N veces 3}
end;
 write('j = ',j); {Cuando vamos a escribir varias cosas seguidas, podemos enviar la
instruccion de esta manera}
END.
Y en pantalla se imprimiria:
1
2
3
4
5
6
7
8
9
10
j = 30
En los ciclos For, podemos seguir dos tipos de direccion. Ascendente (de 1 hasta
N) o descendente (de N hasta 1). Esto lo deberemos indicar en el contador del
siguiente modo (usaremos el ejemplo anterior):
Ascendente
for i:=1 TO N do
...
Descendente
for i:=N DOWNTO 1 do
...
EJEMPLO:
Program Sin_Ciclo;
Begin
WriteLn (`Número = 1');
WriteLn (`Número = 2');
WriteLn (`Número = 3');
WriteLn (`Número = 4');
End.

Program Con_Ciclo;
Var I: Integer;
Begin
For I := 1 To 4 Do
WriteLn (`Número = ', I);
End.

Program Ciclo_1_a_4;
Var I: Integer;
Begin For I := 1 To 4 Do
WriteLn (`Número = ', I);
End.

Program Ciclo_4_a_1;
Var I: Integer;
Begin For I := 4 DownTo 1 Do
WriteLn (`Número = ', I);
 End.

REPEAT:
EL CICLO "REPITA" (Como cariñosamente se le llama en la jerga de los
programadores) actua de manera similar al ciclo WHILE – DO,
con la pequeña diferencia de que en este se ejecutan las instrucciones y despues
se evalua la condición.
El bucle Repeat realiza una serie de instrucciones y, una vez hechas, comprueba
una condicion. En caso de cumplirse, no volvera a repetir dichas instrucciones, y
en caso contrario las ejecutara. Su estructura es:
repeat
instruccion(es);
until (condicion);
- Aclaraciones
Observese que los 3 ciclos, bien implementados, son equivalentes entre si.
Hay que tener especial cuidado en el ciclo que se desea usar: ·
Si se desea hacer un numero de vueltas FIJO, podemos usar cualquiera de los 3. ·
Si las vueltas dependen de una condicion que se modifica dentro del bucle, solo
podemos usar los ciclos WHILE y REPEAT.
· Si queremos comprobar una condicion antes de realizar ciertas instrucciones,
debemos usar el WHILE.
EJEMPLO:

Program REPEAT_a_FOR;
Var I: Integer;
Begin I := 1;
REPEAT WriteLn (`Número ', I); I := I + 1; UNTIL I = 5;
End.

PRO
 Sentencias compuestas
Las sentencias compuestas son grupos de sentencias, separadas cada
una por un punto y coma ";" que son tratadas como una sola sentencia.

Para identificar una sentencia compuesta de un grupo sucesivo de

sentencias se encierran entre las palabras reservadas BEGIN y END.
Uno de los ejemplos más claros de una sentencia compuesta es el
cuerpo de un programa principal en Turbo Pascal, el lenguaje toma todo
lo que existe entre estas dos sentencias como un solo elemento a
ejecutarse aún cuando contenga varias instrucciones o sentencias:

PROGRAM Prueba;

BEGIN
WriteLn('Primera linea de una sentencia compuesta');
WriteLn('Segunda linea de una sentencia compuesta');
WriteLn('Tercera linea de una sentencia compuesta');
END.

El punto y coma que se encuentra antes de la palabra

reservada END puede ser suprimido sin afectar a la compilación. En
ocasiones es necesario repetir un determinado número de veces la
ejecución de una sentencia, ya sea sencilla o compuesta, para realizar
esta tarea Turbo Pascal cuenta con instrucciones específicas para el
tipo de repetición que se requiera.

Ciclos FOR
El ciclo FOR repite una sentencia un determinado número de veces que
se indica al momento de llamar al ciclo.

Lo que hace FOR es que incrementa una variable en uno desde un valor
inicial hasta un valor final ejecutando en cada incremento la sentencia
que se quiere repetir. Su sintaxis es:

FOR identificador := inicio TO fin DO instrucción;

Donde el identificador es la variable que se incrementará, inicio es el

primer valor que tendrá dicha variable y fin es el valor hasta el cual se
incrementará la misma; instrucción es la sentencia (sencilla o
compuesta) que se ejecutará en cada incremento de la variable.

El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La

variable utilizada es "Numero".

PROGRAM Ciclo_FOR;
VAR
Numero : Integer;

BEGIN
FOR Numero := 1 to 50 DO
WriteLn(Numero);
END.

Una de las limitaciones de los ciclos FOR es que una vez iniciado el
ciclo se ejecutará el número de veces predefinido sin posibilidad de
agregar o eliminar ciclos.

Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable
en lugar de incrementarse se decremente. Para ésto cambiamos la
palabra TO por DOWNTO, y colocamos el valor mayor a la izquierda y el
menor a la derecha. Ejemplo:

PROGRAM Ciclo_FOR_2;
VAR
Numero : Integer;

BEGIN
FOR Numero := 50 DOWNTO 1 DO
WriteLn(Numero);
END.

Ciclos WHILE
Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza
mientras se cumpla una condición, por lo tanto es posible controlar el
número de repeticiones una vez iniciado el ciclo. Su sintaxis es:

WHILE condición DO instrucción

Donde condición es la condición que se evaluará, mientras ésta sea
verdadera se ejecutará la instrucción, que es una sentencia simple o
compuesta.

Un programa que escriba los números del 1 al 50, utilizando el ciclo

WHILE se vería como sigue:

PROGRAM Ciclo_WHILE;
VAR
Numero : Integer;

BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN
WriteLn (Numero);
Numero := Numero +1;
END;
END.

Al final del programa la variable Numero guardará el valor 51, que fué el
valor que no cumplió con la condición establecida en el ciclo WHILE.

Ciclos REPEAT-UNTIL
Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia
entre ambos es que en WHILE la condición se evalúa al principio del
ciclo, en cambio en REPEAT-UNTIL se evalúa al final, lo que significa
que en un ciclo REPEAT-UNTIL la sentencia se ejecutará por lo menos
una vez, cosa que puede no ocurrir en el ciclo WHILE. Ejemplo:

PROGRAM Ciclo_RepeatUntil;
VAR
Numero : Integer;
BEGIN
Numero := 1;
REPEAT
WriteLn (Numero);
Numero := Numero + 1;
UNTIL Numero = 50;
END.
Para crear un buen programa es necesario dotarlo con capacidad de
desición con base en las variables o eventos definidos por el
programador, para que el programa sea aplicable en un entorno más
generalizado y no solo para un problema específico.

Para lograr este control se cuenta con las estructuras de control que, en
Turbo Pascal, son las siguientes:

Sentencia IF...THEN...ELSE
Esta expresión es utilizada para ejecutar una sentencia en el caso que
una condición establecida sea verdadera, de lo contrario se podra
ejecutar una sentencia distinta. Su sintaxis es:

IF condición THEN instrucción ELSE otro

Donde condición es la expresión que se evaluará, en caso de ser

verdadera se ejecutará la sentencia dada como instrucción, en caso de
que la condición sea falsa se ejecutara la sentencia dada como otro.
Ejemplo:

PROGRAM IF_THEN_ELSE;

VAR
Contador : Integer;

BEGIN
FOR contador := 1 to 50 DO
BEGIN
IF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');
END;
END.

En este pequeño programa la variable Contador se incrementará desde

1 hasta 50, la sentencia condicional IF verificará si es verdad que
Contador es mayor a 10, de ser así se escribirá en pantalla el valor de la
variable, de lo contrario se escribira en la pantalla un caracter "*". Como
el contador inicia desde 1, tenemos que se imprimiran 10 asteriscos
antres del primer número, que será el 11, valor que si cumple la
condición "Contador > 10" (la hace verdadera).
La sección ELSE con su correspondiente sentencia son opcionales y
pueden omitirse en caso de no necesitarse.

Sentencias IF anidadas
Es posible utilizar en una expresión del tipo IF..THEN..ELSE una
sentencia compuesta como la sentencia a ejecutarse en caso de que la
condición sea verdadera, así como en la sentencia posterior a un ELSE,
de esta forma podemos utilizar otra sentencia IF..THEN..ELSE dentro de
la anterior, para de esta forma evaluar varias condiciones una dentro de
otra. Ejemplo:

IF Numero > 5 THEN

BEGIN
IF Numero <10 THEN Opcion :="Numero;<BR"> IF Numero <30 THEN
Opcion2 :="Numero;<BR"> END;

Selecciones CASE
Esta forma de control se utiliza cuando se va a evaluar una expresión
que puede contener varios datos diferentes y en cada dato deberá
realizar una acción especial. Por ejemplo, si se crea un menú con
diferentes opciones se realizará un determinado proceso para cada
acción, aunque la selección por parte del usuario se haga desde el
mismo lugar.

El siguiente programa ilustra el uso de la forma CASE, el programa

preguntará un número al usuario y lo clasificará de acuerdo a su valor.

PROGRAM Case;
VAR
Numero : Integer;
BEGIN
WriteLn('Introduzca un número entero del 1 al 5: ');
ReadLn(Numero);
CASE Numero OF
1 : WriteLn('El número fué 1');
2 : WriteLn('El número fué 2');
3 : WriteLn('El número fué 3');
4 : WriteLn('El número fué 4');
5 : WriteLn('El número fué 5');
 ELSE WriteLn('El número no estaba en el rango indicado');
END.

GOTO
La sentencia GOTO es una sentencia utilizada para alterar el flujo del
programa, es decir, para ir a ejecutar una sentencia en un lugar diferente
del programa y no la linea siguiente.

El uso de GOTO no es aconsejable ya que destruye el modelo de la

programación estructurada que es la que se utiliza en Turbo Pascal,
además se cuenta con las estructuras de datos anteriores que hacen
casi innecesario su uso.

Para utilizar este tipo de salto es necesario declarar etiquetas, que no

son otra cosa que el identificador que marcará el lugar a donde se
dirigirá el flujo del programa al momento de usar el GOTO. La
declaración de etiquetas se hace antes que la de constantes y variables,
la palabra reservada para su declaración es LABEL. El nombre de la
etiqueta es un nombre de un identificador como cualquier otro, pero al
utilizarse debe terminar con dos puntos ":".

La sintaxis del comando es:

GOTO etiqueta;

Ejemplo:

PROGRAM Uso_del_GOTO;
LABEL
Etiqueta;
BEGIN
WriteLn('Esta linea si se escribirá');
GOTO Etiqueta;
WriteLn('Esta linea no se escribirá');

Etiqueta:
WriteLn('Se efectuó el brinco');
END.

HALT
La instrucción HALT provoca la terminación inmediata de un programa,
sin importar las siguientes instrucciones. Normalmente se utiliza en
casos de error, se despliega un mensaje y se termina el programa.
Ejemplo:

PROGRAM Uso_de_HALT;

BEGIN
WriteLn('Primera linea del programa');
WriteLn('Terminará la ejecución del programa');
HALT
WriteLn('');
END.
= 1;
RE);
Numero := Numero + 1;
UNTIL Numero = 50;
E