EL CODIGO DEL PROGRAMA CAPITULO-5
En este capítulo es uno de los más interesantes. No vamos
a meter ya con lo que es el código principal del programa!! ;)
El código es el conjunto de órdenes que el ordenador debe
seguir. Básicamente estas órdenes serán o bien asignaciones o bien llamadas a funciones.
El código está encerrado entre las palabras claves BEGIN y END.
Las asignaciones consisten simplemente en asignarle un
valor a una variable. Para ello se usa algo como esto: Variable:=
<expresión> ;
Las expresiones ya las vimos en el capítulo anterior. No
hay que olvidar los dos puntos antes del igual ni el punto y coma al final de
la línea.
Como variable podemos poner cualquier variable de las que
vimos en el capítulo sobre variables. (un array, una estructura, etc...)
Y a parte de las asignaciones podemos hacer llamadas a
funciones, cosa que ya veremos cuando hablemos de las funciones.
Pero si sólo pudiésemos hacer esto un programa no podría
ser complejo. Lo que tenemos, además de lo que ya he dicho, son sentencias
condicionales y bucles.
SENTENCIAS CONDICIONALES
Una sentencia condicional es algo como esto:
IF <expresión lógica> THEN
<código1>
ELSE
<código2>;
De manera que si la expresión lógica es cierta se ejecuta
el código1 mientras que si es falsa se ejecuta el código2. También puede
escribirse así:
IF <expresión lógica> THEN <código>;
De esta manera si la expresión es cierta se ejecutará el
código y si es falsa no se hará nada.
Normalmente lo que se hace es encerrar entre un BEGIN y
un END todo el código que será afectado por la sentencia condicional, así, un
ejemplo sería este:
IF
Variable1 = 0 THEN
BEGIN
Variable2
:= 1;
Variable1
:= 4;
END
ELSE
BEGIN
Variable2
:= 2;
Variable1 := 7;
END;
Y aquí ATENCION a dónde están puestos los puntos y coma.
Los puntos y coma se usan en Pascal para
marcar el final de una instrucción. Así después de cada una de las asignaciones
hay uno. Y también debe ir otro al final de la sentencia condicional.
(Después del último END)
BUCLES
Los bucles nos sirven para repetir unas mismas instrucciones
varias veces. Para esto tenemos 5 tipos de bucles:
FOR...TO
Este tipo de bucle sigue esta estructura:
FOR <variable> := <inicio> TO <fin> DO
<código>;
Donde variable es cualquier numérica. (no podemos usar un
String), donde es el número a partir del que empezamos a contar y donde es el
número al que tenemos que llegar para parar de ejecutar .
Pongamos un ejemplo:
FOR Contador := 1 TO 5 DO
BEGIN
Variable1 := Contador;
Variable2 := Variable2 + Contador;
END;
Aquí la sentencia FOR empezaría a contar desde el 1 y
ejecutando una vez el código antes de sumarle uno a. Cuando contador llegue a 5
ya no se ejecutará más el código. Por lo tanto se ejecutará una vez para Contador=1,
otra para Contador=2, para Contador=3, para Contador=4 y para Contador=5. Por
lo tanto el código se ejecutará 5 veces.
Cuidado a la hora de usar 0 como inicio para el contador,
porque de 0 a 5 el código se ejecutaría 6 veces!
También podemos usar DOWNTO en lugar de TO en esta sentencia
y entonces lo que hará será restar uno al contador en vez de sumarlo. Entonces
el número al que ha de llegar tiene que ser MENOR que el inicial, es decir, ha
de ser algo como esto:
FOR Contador := 5 DOWNTO 1 DO
Variable := Contador;
DO...WHILE
Este otro bucle sigue esta estructura:
DO
<código>
WHILE <expresión>;
En este caso no hace falta encerrar entre BEGINEND el
código porque ya queda delimitado por el DOWHILE y no hay lugar a confusión.
Este bucle es similar al FOR. Lo que hace es repetir el código mientras la
expresión sea cierta. PERO la comprobación la hace después de haber ejecutado
el código. Esto es importante porque gracias a eso el código se ejecutará
SIEMPRE una vez, como mínimo.
Así, esto se ejecutaría una vez:
A
:= 8;
DO
A
:= 8;
WHILE
A = 9;
En cambio esto se ejecutaría 3 veces:
A
:= 1;
DO
A
:= A + 1;
WHILE
A <= 3;
Al acabar la primera ejecución A sería igual a 2, al
acabar la 2ª A sería igual a 3 y al acabar la tercera A sería igual a 4. Como 4
no es ni menor ni igual a 3 el bucle de para.
WHILE...DO
Este es prácticamente idéntico al anterior. Tiene esta
estructura:
WHILE <expresión> DO
<código>;
En este caso vuelve a ser necesario el BEGIN-END si
queremos que lo que se repita sea más de una instrucción.
En este bucle la comprobación se hace ANTES de ejecutar
el código y por eso puede que el código no se ejecute ninguna vez en el caso de
que la condición sea ya al principio falsa.
REPAT...UNTIL
Este bucle sigue la siguiente estructura:
REPEAT
<código>
UNTIL <expresión>
En este caso no es necesario el BEGIN-END y lo que hace
este bucle es repetir el código hasta que la expresión sea cierta, o lo que es
lo mismo: lo repite mientras la expresión sea falsa. Es decir, algo como esto
no pararía nunca de ejecutarse:
REPEAT
A := A + 1;
UNTIL 2 = 3;
Aquí le estamos diciendo que repita el código hasta que 2
sea igual a 3. Y... como yo creo que va a tardar un ratito en que 2 sea igual a
3 pues... este bucle no acabaría nunca y tendríamos que hacer un reset o pulsar
CTRL+C si estamos ejecutándolo desde el IDE. Bueno. Y esto es todo por hoy. Tal
vez parezca que no he dicho gran cosa, pero ahora ya sólo nos falta dar las
funciones para poder empezar a hacer programas completos. Por supuesto, en el
próximo capítulo toca funciones. ;)
DESCARGAR CAPITULO 5 VERSIÓN PDF
CAPITULO 6
0 comentarios: