EXPRESIONES

Bueno... antes de nada esta vez quiero decir que he estado a punto de cargarme el HD enterito y que hace poco me cargué más de la mitad de la base de mensajes. Con lo cual he perdido todos los mensajes sobre el cursillo y el índice que tenía hecho. Pero por suerte, todabía tengo un montón de hojas sueltas en las que tengo todos los esquemas que me planteé antes de empezar así que por ahora parece que pese a todo podré continuar. O:)

Hoy nos toca hablar sobre las expresiones. Es un asunto sencillo pero que es importante que quede claro. Una expresión, para decirlo de manera sencilla, podríamos decir que es un cálculo. Por ejemplo, una expresión podría ser esto: (7+8*15-34)/10

Puesto que es un cálculo podemos indicar operaciones. Tenemos dos tipos de operaciones las numéricas y las lógicas. Las numéricas las realizamos con números y dan como resultado un número. Las lógicas las podemos realizar con números o con valores booleanos y dan como resultado un valor booleano.

OPERACIONES NUMERICAS

Empecemos por las numéricas. Como operaciones numéricas tenemos estas:

+ : Suma.

- : Resta.

* : Producto.

% : Módulo. (es decir, haya el resto de la división) EJ: 4 % 3. Da el resto de 4 / 3, que es 1.

/ : División de reales. Esta división da como resultado un número real. Acepta como operandos tantos números reales como enteros.

Div : División de enteros. Esta división da como resultado un número entero y no acepta como operandos números reales.

Los operandos que podemos utilizar son: valores inmediatos, constantes o variables. Por ejemplo, en este caso:

Const

Constante = 7;

Var

Tabla : Array [0..10] of Byte;

A : Word;

Begin

A := 8 + Tabla[9] - Constante;

End.

Aquí "8" sería un valor inmediato, "Tabla[9]" una variable, y "Constante" una constante. Así de sencillo.

Un punto importante a tener en cuenta es la preferencia de las operaciones. Es decir, que " 8 + 3 * 2 " NO es lo mismo que " (8 + 3) * 2 ". En el primer caso se calcula primero 3*2 y al resultado se le suman 8 mientras que en el segundo se calcula primero 8 + 3 y el resultado se multiplica por 2. La preferencia es la misma que utilizamos normalmente para hacer operaciones matemáticas: primero los paréntesis, luego las multiplicaciones/divisiones/módulos y por último las sumas.

Una expresión numérica puede utilizarse en una asignación, como en el ejemplo anterior, para pasar un parámetro a una función, etc... Por ejemplo, en lugar de "A := 8 + Tabla[9] - Constante" podríamos cambiarlo y poner "A := 8 + Tabla[Tabla[3]+Constante*2] - Constante".

Con esto se calcularía 7 * 2 (7 es el valor de "constante"), se le sumaría el valor almacenado en la posición 3 de la tabla y ese resultado se utilizaría como índice de la tabla. Se leería en valor que indique esa posición y se le sumaría 8 y se le restaría 7. (la constante)

OPERACIONES NUMERICAS

Las operaciones lógicas devuelven siempre verdadero (true) o falso (false). Se utilizan para hacer comprobaciones.

Las operaciones lógicas de que disponemos son estas:

= : Devuelve verdadero si los dos operandos son iguales

<> : Devuelve verdadero si los dos operandos son diferentes

> : Devuelve verdadero si el primer operando es mayor que el segundo

< : Devuelve verdadero si el segundo operando es mayor que el primero

>= : Verdadero si el primer operando es mayor o igual que el segundo

<= : Verdadero si el primer operando es menor o igual que el segundo

and : Devuelve verdadero si las dos expresiones lógicas son verdaderas

or : Verdadero si una o las dos expresiones lógicas son verdaderas

not : Devuelve verdadero si la expresión es falsa

Y ahora expliquemos esto un poquito:

Las primeras 6 operaciones son muy sencillas. Sirven para comparar dos expresiones numéricas y nos devuelven el valor booleano correspondiente. Así, por ejemplo, la expresión "3 = 2" siempre nos devolverá falso, pero la expresión "A = 2" tal vez devuelva falso o tal vez devuelva verdadero, ya que dependerá de si la variable A está almacenando o no el valor 2 en el momento en que se hace la comprobación.

Como siempre, podemos complicar las cosas y escribir cosas como esto:

(Tabla[3] - Constante + 8 * Tabla[ Tabla[ 9 - 3 ] + 9) >= Tabla[5]

(Si alguien no acaba de ver claro esto, que pruebe a desglosar en pasos esta expresión, tal y como he hecho yo con las anteriores, y me lo comente)

Las 3 últimas operaciones de la lista ya no trabajan con expresiones numéricas sino con expresiones lógicas. Teniendo arriba la función de cada una creo que lo mejor es explicarlo mediante ejemplos.

(3 = 2) or (1 = 4) daría siempre falso porque la expresión (3 = 2) da falso y la expresión (1 = 4) también. Y "or" sólo devuelve verdadero cuando al menos una de las expresiones es verdadera.

(3 = 2) or (1 = 1) daría verdadero porque aunque (3 = 2) es falso, (1 = 1) es verdadero.

((3 = 2) or (1 = 1)) and (9 = 3) devolvería falso porque ((3=2) or (1=1)) da verdadero pero (9 = 3) da falso. Y para que "and" devuelva verdadero han de ser verdaderas las dos expresiones.

not (1=3) daría verdadero. Porque (1=3) da falso y "not" devuelve lo contrario de lo que vale la expresión dada.

Hasta aquí es sencillo, pero hay que tener en cuenta que no nos vamos a limitar a hacer que el Turbo Pascal nos diga que 1 no es igual a 3. La finalidad de esto es mucho más útil, por supuesto. Hay que recordar que para construir las expresiones lógicas podemos valernos de cualquier expresión numérica. Esto es, si tenemos dos expresiones numéricas como estas:

(Tabla[4] - 8) * 34

(Contante + A) % Tabla[3]

Podemos hacer una expresión lógica que compare esas dos expresiones, como por ejemplo:

 ( (Tabla[4] - 8) * 34 ) >= ( (Constante + A) % Tabla[3] )

Y una vez tenemos esta expresión lógica podemos combinarla con otras expresiones lógicas para hacer expresiones lógicas más complejas, por ejemplo algo como esto:

((( Tabla[4] - 8) * 34 ) >= ((Constante + A) % Tabla[3])) or (2=(1+A))

(si alguien quiere entretenerse, podría ser un buen ejercicio calcular para qué valores de Tabla[4], Tabla[3] y A la expresión ENTERA es verdadera.

 Uhm... creo que por hoy no tenía que decir nada más. :m ... Tampoco os puedo asegurar que aquí esté todo lo que tenía que decir, porque he perdido los esquemas, pero... bueno... creo que sí. O:)

EL CODIGO DEL PROGRAMA

Bueno... este capítulo sale con un pelín de retraso, pero... bueno... es que entre que hoy tenía el global de física y que ayer me quedé viciado al Need for Speed... O:)

Pero bueno, no importa porque 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 símplemente en asignarle un valor a una va- riable. 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 linea. 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 puedié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 instrució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 instruciones 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 BEGIN-END el código porque ya queda delimitado por el DO-WHILE 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 instrució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 siguente 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.