Pascal se compone de una serie de "PIEZAS" (Comandos, procedimientos, funciones, ciclos, sentencias, etc) las cuales permiten armar una determinada aplicación para dar solución a una necesidad o problema,aqui veremos la explicacion de los comandos básicos.
1. ESTRUCTURA BÁSICA DE UN PROGRAMA PASCAL
Un programa escrito en Pascal tendrá generalmente la siguiente forma:
Program nombre_programa;
BEGIN
(* comandos *)
END.
Program, como se ve, contiene el nombre del programa y sirve para identificarlo.
Fuera de eso, no nos vamos a detener en lo que significa ya que no tiene ninguna
otra utilidad práctica.
BEGIN y END. (con el punto) marcan el inicio y el final del programa. De hecho,
estas dos instrucciones marcan un "bloque" que es un conjunto de instrucciones
que tienen dependencia entre sí (un programa necesita todas las instrucciones
entre BEGIN y END para cumplir la función que se le ha asignado). Después veremos
otras instrucciones que requieren el uso de BEGIN y END.
Entre Program y BEGIN puede haber otros comandos, llamados declaraciones. Estos
comandos muestran todas las variables, constantes y valores que serán utilizados en
el programa. Las declaraciones pueden ser (en este orden):
uses
label
const
type
var
procedure
function
La función "uses" la explicaré más adelante, pero básicamente sirve para incluir
comandos extra a Turbo Pascal, para darle más funcionalidad y ampliar sus capacidades.
Habitualmente se usa de la siguiente manera:
Program n;
uses CRT;
...
"Label" marca las "etiquetas" en el programa. Estas "etiquetas" son como "letreros" que
indican a Pascal "aquí hay tal cosa". Esto sirve si quieres "saltar" a ese código, por
ejemplo si quieres que cierta parte del programa no se ejecute. Para ello se usa Goto.
Label se usa de esta manera:
Label 1, 2, 3, a, b, c, hola;
Cualquier palabra, excepto una palabra reservada, se puede usar como etiqueta.
"Const" declara una constante. Es un valor que recibe un nombre; este valor no puede ser
cambiado por todo el programa. A diferencia de las variables, no es necesario especificar
su tipo (p. ej. decir que es un número entero). Ej:
Const PI = 3.141593;
LetraA = 'a';
"Type" declara un tipo especial de variable. Esto lo explicaré con detalle más abajo.
"Var" declara una variable, es decir, reserva el espacio en el computador para poder ocupar
esa variable. ¡TODAS LAS VARIABLES DEBEN SER DECLARADAS! Si no, el compilador de Pascal les
arrojará un error y el programa no funcionará.
Se usa así:
var nombrevar: tipo;
Por ejemplo:
var a, b, c : integer; (* declara 3 variables enteras *)
d : char; (* declara una variable que puede almacenar una sola letra *)
...
"Procedure" y "Function" las explicaré más adelante.
Recuerda que después de cada comando va un punto y coma (;), a menos que el comando
así lo especifique (como BEGIN, que JAMÁS lleva punto y coma).
2. COMANDOS BÁSICOS
OK, ya sabemos como hacer las declaraciones en Pascal, pero ¿de qué sirve si no sabemos
como usarlas? Bueno, para eso están los comandos en Pascal.
Lo primero es lo primero. ¿Cómo queremos que el usuario sepa que queremos que haga algo?
Bueno, para eso usaremos el comando Write() o Writeln() que escriben un mensaje en la
pantalla del computador.
Write y Writeln se usan de la siguiente manera:
Write(lo que sea);
La principal diferencia entre ambas es que al usar Writeln() el computador salta una
línea después de escribir. Un ejemplo de un programa Pascal que escribiera un mensaje
en la pantalla sería:
Program mensaje;
(* no vamos a usar variables, así que no hay declaraciones *)
BEGIN
Write ('Yo me llamo Z');
Writeln (4);
Write ('2+2=');
Writeln (2+2);
END.
Eso entrega:
Yo me llamo Z4
2+2=4
Fíjense que el texto va entre comillas simples (''), mientras que los números no. Las
comillas hacen que Pascal considere todo eso como una palabra y no como un número.
También puede ir, como se ve, una operación matemática en Write y Writeln. P. ej.:
Writeln (3*(4+5)-1);
Resultado: 26
Para que el computador reciba datos debemos usar el comando opuesto, que es Read() (o
Readln() ). Este comando espera a que se escriba el valor o los valores pedidos y luego
lo ingresa a la variable especificada entre paréntesis. P. ej.:
Program Multiplicacion;
Var
a,b : Real; (* vamos a usar las variables a y b, así que las declaramos *)
BEGIN
Readln (a);
Readln (b);
Writeln (a*b);
END.
Si queremos, podemos en el intertanto asignar el resultado a otra variable para guardarlo,
si necesitamos usarlo otra vez. Esto se hace con el operador Asignación ( := ). Y no, no
es una carita. La asignación se hace de la siguiente manera:
NombreVariable := Valor
Por ejemplo, si vamos a calcular la suma de dos números y luego mostrar su promedio, usamos
el siguiente programa:
Program Promedio;
Var
a,b,prom : Real;
BEGIN
Readln (a,b);
prom := a+b;
Writeln (prom);
Writeln (prom/2);
END.
Nótese que Read() y Write() se pueden compartir entre varias variables. Por ejemplo, para
leer 3 variables DEL MISMO TIPO, podemos usar:
Readln (a);
Readln (b);
Readln (c);
o, simplemente:
Readln (a, b, c);
Y si queremos escribirlas separadas por un espacio, podemos poner:
Writeln (a,' ',b,' ',c);
También, si escribimos una variable real con Write() vamos a obtener algo así como:
3.14000000000000E+00
Para prevenir eso, colocamos la variable real de la siguiente forma:
Writeln (variable:1:n);
donde n es el número de decimales. Por ejemplo, (3.14:1:1) devolverá (3.1).
3. TIPOS DE VARIABLES
Esto lo voy a explicar rápido. Al usar
var nombre : tipo;
debemos especificar el tipo de la variable, el cual puede ser:
Byte: entero corto natural, entre 0 y 255.
ShortInt: entero corto con signo, entre -128 y 127.
Integer: entero con signo, entre -32768 y 32767.
Word: entero natural, entre 0 y 65535.
LongInt: entero largo con signo, entre -2147483648 a 2147483647.
Real: número real, con decimales.
Single: ídem, más corto.
Double: ídem, más largo.
Extended: número real larguísimo.
Comp: número real parecido a Double, más largo.
Boolean: valor lógico (verdadero o falso), 1=V, 0=F
Char: carácter (una sola letra, número o símbolo)
String: conjunto de letras, números y signos con espacio para 255 caracteres.
Estos dos últimos, al asignarles un valor, éste se debe escribir entre comillas
simples, por ejemplo:
Letra := 'a' (* Letra es Char *)
Nombre := 'Karen' (* Nombre es String *)
Recuerda que NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE. Repito:
NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE
NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE
NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE
(la razón es obvia)
Ah, otra cosa. Aquí se pueden declarar también los arrays ("Arreglos"). Un array
es un conjunto de variables que son la única excepción a la regla anterior, ya que
comparten el mismo nombre. Se diferencian por un número que se denomina índice. Los
arrays se declaran de cualquiera de las siguientes formas:
Var
nombrearray: Array [a..b] of tipo;
o
Type
Vector = Array [a..b] of tipo;
Var
nombrearray: Vector;
El array contendrá n variables, yendo de A hasta B. Por ejemplo, si declaras:
Type
Vector = Array [1..5] of Integer;
las variables de tipo Vector tendrán 5 elementos enteros (1, 2, 3, 4, 5).
Un array se usa de la misma manera que una variable normal, pero debes especificar
el índice del elemento que deseas ver, por ejemplo, en el array "X" de tipo Vector, si
quieres ver el tercer elemento debes usar:
Writeln (X[3]);
y para modificarlo:
X[3] := 4;
También se pueden crear arrays de dos índices (dos dimensiones) que se pueden representar
como una tabla, por ejemplo las de Excel, que tienen un índice como letra y un índice como
número (A5, A7, B9, Z13, etc.) Se declaran igual que las otras, pero con la siguiente
modificación:
Type
Matriz = Array [a..b][x..y] of tipo;
...
y para ocuparlas:
CualquierMatriz[3][5] := algo;
En los índices se puede colocar cualquier tipo de secuencia que siga un orden lógico, es
decir, es correcto colocar lo siguiente:
Type
Matriz = Array [1..10]['a'..'z'] of Integer;
lo que nos dejaría algo parecido a Excel (con una letra y un número)
Aqui vemos algo nuevo ("Type"). Este comando declara un tipo especial de variable.
Por ejemplo, los arrays. Luego, en la sección Var, puedes simplemente declarar el nombre
del tipo especial que creaste. Otro ejemplo sería:
Type
CadenaCorta = String[16];
Mes = 1..12;
Var
Palabra: CadenaCorta;
Actual: Mes;
Aquí se declara una variable de tipo "CadenaCorta" que es una variable "String" (conjunto de
letras) con un tamaño máximo de 16 caracteres, y una variable entera que tiene valores entre 1
y 12. Éstos son los tipos "subrango", modificaciones, limitaciones o especificaciones a los
valores de los otros tipos.
Tambíen se pueden declarar los tipos enumerados, que son identificadores que internamente toman
un valor "secuencial", p. ej.:
Type
Estaciones = (primavera, verano, otoño, invierno);
Este ejemplo lo saqué de lapolitecnica.net. Para el computador, Primavera será como el 0, Verano
como el 1, etc.
4. CONDICIONES
¿Qué pasa si quieres que el programa decida algo por su cuenta? Para eso usamos las condiciones,
que son consultas o comparaciones que hace el computador, y devuelven un valor verdadero o falso.
Hay dos tipos de condiciones: IF y CASE OF.
A. Condición IF
La forma general de la condición IF es la siguiente:
If (condición) then
begin
(* instrucciones *)
end;
donde (condición) es una comparación lógica que puede ser verdadera o falsa, como:
< menor que
> mayor que
= igual a (SIN dos puntos)
>= mayor o igual que
<= menor o igual que
<> distinto a
Las instrucciones después de Then (entre begin y end;) serán ignoradas si la condición es
falsa.
Por ejemplo, si queremos ver si un número es mayor que 5, hacemos lo siguiente:
Program Mayorque5;
var
a : byte;
BEGIN
Write ('Escriba un número: ');
Readln (a);
If (a>5) then
Writeln ('Es mayor que 5');
END.
Si es una sola instrucción, no es necesario colocar Begin ni End separando las instrucciones.
Nótese que End lleva punto y coma (end;).
Si queremos que cierto grupo de instrucciones se realize solo si la condición es FALSA usamos
la instrucción ELSE. Así:
If (condición) then
begin
(* esto solo se hará si la condición es verdadera *)
end
Else
begin
(* esto solo se hará si la condición es falsa *)
end;
¡El primer END no lleva punto y coma si está presente la instrucción ELSE!
Un ejemplo de IF-THEN-ELSE sería una ampliación del programa anterior:
Program Mayoromenorque5;
Var
a : byte;
BEGIN
Write ('Escriba un número: ');
Readln (a);
If (a>5) then
Writeln ('Es mayor que 5')
Else
Writeln ('Es igual o menor que 5');
END.
Si queremos asegurarnos de que se cumplan varias condiciones en una instrucción IF, usamos
los operadores lógicos. Éstos son: And (Y), Or (Y/O), Xor (O), Not (NO). Por ejemplo, si
queremos asegurarnos de que dos números sean positivos antes de hacer algo, usamos:
If (a>0) and (b>0) then
...
Si a es negativo o b es negativo, no hará nada, porque se requiere que ambos números sean
positivos. Si queremos asegurarnos de que al menos uno es positivo, colocamos Or en vez de
And. Si queremos asegurarnos de que uno y solo uno es positivo, usamos Xor (Or exclusivo).
Not niega la condición. Es decir que Not (a=b) es igual a (a<>b).
B. Condición CASE OF
Si tenemos un grupo de instrucciones IF muy largo en que se compare varias veces la misma
variable, quizá convenga cambiarlo por la instrucción Case Of. Por ejemplo:
(* estado civil *)
If (Codigo=1) then
Estado:='Soltero';
If (Codigo=2) then
Estado:='Casado';
If (Codigo=3) then
Estado:='Viudo';
If (Codigo=4) then
Estado:='Divorciado';
...
Si tenemos que ver por 30, 40 o 50 valores, no creo que alguien tenga la paciencia como para
escribir IF, THEN, etc., 30, 40 o 50 veces. En vez de eso es mejor usar Case Of de la siguiente
forma:
Case (variable) Of
(valor1): begin
(* instrucciones *)
end;
(valor2): begin
(* instrucciones *)
end;
...
(valorn): begin
(* instrucciones *)
end
End;
o
Case (variable) Of
(valor1): begin
(* instrucciones *)
end;
(valor2): begin
(* instrucciones *)
end;
...
Else
begin
(* instrucciones *)
end
End;
Nótese que el penúltimo End no lleva punto y coma. Esto ocurre porque hay dos instrucciones
End juntas.
Viendo esto, podemos cambiar el ejemplo del estado civil que vimos anteriormente por:
Case Codigo of
1: Estado:='Soltero';
2: Estado:='Casado';
3: Estado:='Viudo';
4: Estado:='Divorciado';
End;
Las instrucciones después de Else solo se ejecutarán si ninguno de los valores es verdadero.
También los valores se pueden agrupar si se realiza la misma operación para varios valores. P. ej.:
Case n of
1,2,3: Writeln ('Menor que 4');
4: Writeln ('Igual que 4');
Else
Writeln ('Mayor que 4');
End;
5. CICLOS
Si se va a repetir una misma instrucción muchas veces, sería ridículo escribir, por ejemplo:
Writeln (5*1);
Writeln (5*2);
Writeln (5*3);
Writeln (5*4);
Writeln (5*5);
Writeln (5*6);
Writeln (5*7);
Writeln (5*8);
Writeln (5*9);
Writeln (5*10);
Writeln (5*11);
Writeln (5*12);
...
Para evitar eso se usan los ciclos, que repiten una instrucción o grupo de instrucciones
tantas veces como se necesita. Los 3 ciclos básicos son los ciclos While, Repeat y For.
Comencemos por lo más fácil:
A. Ciclo FOR
Este ciclo repite las instrucciones un número fijo de veces, aumentando o disminuyendo una
variable que cuenta cada vez que se repiten las instrucciones. Se usa de la siguiente manera:
For variable := valorinicial To valorfinal Do
begin
(* instrucciones *)
end;
o
For variable := valorinicial DownTo valorfinal Do
begin
(* instrucciones *)
end;
Esto hará que se repitan las instrucciones hasta que la variable tenga un valor igual o mayor
a valorfinal. Irá aumentando de 1 en 1 o disminuyendo de 1 en 1 dependiendo de si se usa To o
DownTo, a partir del valor valorinicial. Por ejemplo, las instrucciones Writeln que vimos
anteriormente podrían ser resumidas en:
For i:=1 to 12 do
Writeln (5*i);
(Recuerda que si hay una sola instrucción podemos omitir begin y end)
Un ejemplo de programa que usa un ciclo FOR es uno que calcule el factorial de un número N.
El factorial de N (N!) se define como 1 * 2 * 3 * 4 * 5 * 6 * ... * N, es decir el producto de
los N primeros números naturales. Aquí va:
Program factorial;
Label 1, 2;
Var N, i, f : LongInt;
resp : Byte;
BEGIN
1:
Write ('Ingrese el número deseado');
Readln(N);
f := 1;
For i := 1 to N do
f := f * i;
Writeln (N,'! = ',f);
2:
Write ('¿Desea ejecutar nuevamente el programa? [1=Sí/2=No]');
Readln (resp);
If (resp<1) or (resp>2) then
Goto 2;
If (resp=1) then
Goto 1;
END.
Si usáramos DownTo, el resultado sería el mismo, pero tendríamos que cambiar lo siguiente:
For i := 1 to N do
por
For i := N DownTo 1 do
B. Ciclo WHILE y Ciclo REPEAT
Los ciclos While y Repeat habitualmente se usan cuando no se sabe con exactitud la cantidad de veces
que se va a repetir el proceso. La estructura de éstos es:
While (condición) Do
begin
(* instrucciones *)
end;
y
Repeat
(* instrucciones *)
Until (condición);
A diferencia de los otros ciclos, si se dan cuenta, Repeat no lleva begin ni end.
Las principales diferencias entre Repeat y While son dos:
1. En While, si la condición es falsa desde el principio, el ciclo no se ejecuta ninguna vez.
En Repeat, el ciclo se ejecuta al menos una vez porque la condición se comprueba al final.
2. En While, el ciclo se ejecuta mientras la condición sea verdadera; en Repeat el ciclo se ejecuta
mientras la condición sea falsa.
Un ejemplo de cada uno ahora.
El ejemplo de Repeat va a ser un programa que espera a que el usuario adivine un número al azar. Si lo
adivina, aparece un mensaje indicándolo; si no, el computador le indica al usuario si el número es mayor
o menor.
Para ello vamos a usar la función Random(n) que devuelve un número entero entre 0 y n. Como es una función
de lo que podríamos llamar "Pascal extendido", es decir, una función extra de Pascal, debemos incluirla
en el programa con uses crt;.
Program Adivina;
Uses CRT;
Var
Azar, Resp, Intentos : Integer;
BEGIN
Randomize;
Writeln ('Yo voy a pensar un número entre cero y cien.');
Writeln ('Debes adivinarlo en el menor número de intentos posible. Te daré pistas.');
Azar := Random (200);
Repeat
Readln (Resp);
If (Resp<Azar) then
Writeln ('Um... no. Más alto.');
If (Resp>Azar) then
Writeln ('Demasiado.');
Intentos := Intentos + 1;
Until (Resp=Azar);
Writeln ('¡Lo lograste!');
Writeln ('Te costó ',Intentos,' intentos');
Writeln ('Presiona cualquier tecla');
Readkey;
END.
Aquí, además de Repeat... Until usamos las funciones especiales Random(), Randomize y Readkey(). Las
explicaré más abajo con detalle.
Un ejemplo de ciclo While sería simular un bucle for, como por ejemplo mostrar la tabla del 4.
Program Whileofor;
Var
K : Byte;
BEGIN
K:=1; (* valor inicial *)
While (K<=10) do
Begin
Writeln ('4*',K,'=',4*K);
K:=K+1;
End;
END.
De hecho, Repeat y While son básicamente lo mismo, y cualquiera de ellos se puede adaptar para cumplir la
función de For.
6. OPERADORES Y FUNCIONES PREDEFINIDAS
(Explicación rápida otra vez. Bueno, esto es intuitivo)
Estos son los operadores que se usan en Pascal para operaciones matemáticas:
+ Suma
- Resta
* Multiplicación
/ División real (si intentas dividir enteros con / te dará error)
DIV División entera (sin decimales, no sirve para reales)
^ Exponente (elevado a)
MOD Resto de una división entera
Estos son los operadores lógicos (ven si algo es verdadero o falso):
> Mayor que
< Menor que
= Igual a
<= Menor o igual a
>= Mayor o igual a
<> Distinto
AND Y (A Y B = V ssi A = V y B = V)
OR Y/o (A O B = V si A = V y/o B = V)
XOR O exclusivo (A Ox B = V ssi A distinto de B)
NOT No ((No V) = F, (No F) = V)
Estos son los símbolos de agrupación y de orden en Pascal:
(* *) Comentario (lo escrito dentro no afecta al programa)
{ } Comentario
( ) Separa valores, p. ej. K(1)
[ ] Indica índice de algo (un array)
:= Asignación de valor
: Declaración de variable
Estas son las funciones más comunes en Pascal:
Abs(x) Valor absoluto (|x|)
Random(x) Número al azar entre 0 y x (para que no se repitan usa Randomize;)
Sqrt(x) Raíz cuadrada de x
Trunc(x) Parte entera de un número real x (Trunc(3.141593) = 3)
Frac(x) Parte fraccionaria de un número real x (opuesto a Trunc)
Round(x) Redondea x (lo aproxima al entero más cercano)
Ord(x) Código de una letra, p. ej. Ord('A') = 65
Chr(x) Letra correspondiente al código, p. ej. Chr(65) = 'A'
Concat(s1,s2) Une las cadenas s1 y s2 en otra cadena
Length(s) Muestra el tamaño de una cadena, ej: Length('Alvaro') = 6
Arctan(x) Convierte x a radianes
Sin(x) Seno de x
Cos(x) Coseno de x
Exp(x) Número irracional e (2.718281828...) elevado a x.
Int(x) Parte entera del número x
Ln(x) Logaritmo natural/neperiano del número x
Sqr(x) Cuadrado de x
7. COMANDOS MISCELÁNEOS Y OTROS
Misceláneos:
Delay(n); Hace una pausa de n milisegundos (requiere uses crt;)
Readkey; Espera a que se presione una tecla, si se usa como función le asigna
a la variable la tecla presionada, p. ej. A := Readkey;
(requiere uses crt;)
Randomize; Reinicializa los números aleatorios para que no se repitan al usar Random()
(requiere uses crt;)
ClrScr; Borra la pantalla (requiere uses crt;)
Goto lugar; Salta a la etiqueta de nombre lugar.
Palabras reservadas (no se pueden usar como nombres de variables):
PROGRAM CONST TYPE VAR FUNCTION
PROCEDURE BEGIN END INTEGER REAL
BOOLEAN CHAR STRING RECORD SET
FILE ARRAY BYTE REPEAT UNTIL
WHILE FOR DO TO DOWNTO
IF THEN ELSE CASE
8. PROCEDIMIENTOS Y FUNCIONES
Con estos términos... ejem, es decir, con esto termino.
Un procedimiento es un sub-programa independiente que cumple una función específica dentro del
programa. Tiene sus propias variables, como un programa aparte. Se declara con Procedure, de la
siguiente forma:
Program programa;
...
Procedure nombre(argumento1: tipo; argumento2: tipo...);
begin
(* instrucciones *)
end;
BEGIN
...
nombre(argumentos);
...
END.
¡El END del procedimiento lleva punto y coma! Que no se te olvide.
Una función es algo muy parecido al procedimiento, pero devuelve un valor, así que se le puede
llamar desde una variable. Se declara igual que un procedimiento, pero con un cambio importante:
Function nombre(argumento1: tipo...) : TIPO;
begin
...
nombre := algo;
end;
...
BEGIN
variable := nombre(x);
...
Es decir, se debe indicar si el valor que entrega es Integer, Byte, etc.
Un ejemplo de ambos comandos sería, um... Rescatemos el programa de factoriales de más arriba.
Program factorial;
Label 1, 2;
Var N, i, f : LongInt;
resp : Byte;
BEGIN
1:
Write ('Ingrese el número deseado');
Readln(N);
f := 1;
For i := 1 to N do
f := f * i;
Writeln (N,'! = ',f);
2:
Write ('¿Desea ejecutar nuevamente el programa? [1=Sí/2=No]');
Readln (resp);
If (resp<1) or (resp>2) then
Goto 2;
If (resp=1) then
Goto 1;
END.
Supongamos que nos piden calcular el coeficiente binomial de n y k (n sobre k). Este valor, usado
en combinatoria, se define como:
/n\ n!
| | = ----------
\k/ k!(n-k)!
Es decir, factorial de n dividido por el producto del factorial de k y del factorial de (n - k).
Sería bastante tedioso, por decir lo menos, reescribir el ciclo for varias veces. Pero, ¿y si hacemos
una función? Aquí va:
Program CoeficienteBinomial;
Label 1, 2;
Var n, k, resp: Integer;
n_sobre_k: LongInt;
Procedure Prompt (texto:String; var valor:Integer);
begin
Write (texto,' ');
Readln (valor);
end;
Function Factorial (n: Integer): LongInt;
var
f: LongInt; (* solo declaramos aquí las que no están en los argumentos *)
i: Integer;
begin
f := 1;
For i := 1 to N do
f := f * i;
Factorial := f
end;
BEGIN
1:
Prompt('Ingrese N:', n);
Prompt('Ingrese K:', k);
n_sobre_k := Factorial(n) DIV (Factorial(k) * Factorial(n-k));
Writeln ('El valor de N sobre K es: ', n_sobre_k);
2:
Prompt('¿Desea ejecutar nuevamente el programa? [1=Sí/2=No]', resp);
If (resp<1) or (resp>2) then
Goto 2;
If (resp=1) then
Goto 1;
END.
Fíjense en varias cosas. Por ejemplo, en el procedimiento Prompt, colocamos VAR antes del
argumento valor. Eso es para que el procedimiento pueda modificar el valor de la variable "valor"
(qué redundante).
También, si se fijan, para asignarle el valor a la función, se debe usar como otra variable más.
Por ejemplo, la siguiente función daría siempre el valor 4 a una variable:
Function Cuatro (): Byte;
begin
Cuatro := 4;
end;
