Los nombres de las variables siguen las reglas que ya hab�amos mencionado para los identificadores en general, y no se indica ning�n punto y coma entre la palabra «var» y el nombre de la variable (o variables que se declaran).
Con la palabra string decimos que la variable nombre va a contener una cadena de caracteres (letras o n�meros). Un poco m�s adelante, en esta misma lecci�n, comentamos los principales tipos de datos que vamos a manejar. En concreto, string[20] indica que el nombre podr� estar formado hasta por 20 letras o n�meros
Nota: en la variante del lenguaje Pascal conocida como «Extended Pascal», la longitud m�xima de una cadena de texto se indica con par�ntesis, de modo que si alg�n compilador protesta con «string[20]», habr� que probar con «string(20)».
Cuerpo del programa: En �l comenzamos escribiendo un mensaje de aviso. Esta vez se ha empleado writeln, que es exactamente igual que write con la �nica diferencia de que despu�s de visualizar el mensaje, el cursor (la posici�n en la que se seguir�a escribiendo, marcada normalmente por una rayita o un cuadrado que parpadea) pasa a la l�nea siguiente, en vez de quedarse justo despu�s del mensaje escrito.
Despu�s se espera a que el usuario introduzca su nombre, que le asignamos a la variable «nombre», es decir, lo guardamos en una posici�n de memoria cualquiera, que el compilador ha reservado para nosotros, y que nosotros no necesitamos conocer (no nos hace falta saber que est� en la posici�n 7245 de la memoria, por ejemplo) porque siempre nos referiremos a ella llam�ndola «nombre». De todo esto se encarga la orden readln.
Si queremos dar un valor a la variable nosotros mismos, desde el programa, usaremos la expresi�n := (un s�mbolos de «dos puntos» y otro de «igual», seguidos, sin espacios entre medias), as�:
Edad := 17;
Finalmente, aparece en pantalla la palabra «Hola» seguida por el nombre que se ha introducido. Como se ve en el ejemplo, «writeln» puede escribir varios datos, si los separamos entre comas.
En Pascal debemos declarar las variables que vamos a usar, avisar a nuestro compilador para que les reserve espacio. Esto puede parecer inc�modo para quien ya haya trabajado en lenguaje Basic, pero en la pr�ctica ayuda a conseguir programas m�s legibles y m�s f�ciles de corregir o ampliar. Adem�s, evita los errores que puedan surgir al emplear variables incorrectas: si queremos usar «nombre» pero escribimos «nombe», la mayor�a de las versiones del lenguaje Basic no indicar�an un error, sino que considerar�an que se trata de una variable nueva, que no tendr�a ning�n valor, y normalmente se le asignar�a un valor de 0 o de un texto vac�o.
En Pascal disponemos de una serie de tipos predefinidos, y de otros que podemos crear nosotros para ampliar el lenguaje. Los primeros tipos que veremos son los siguientes:
- Integer. Es un n�mero entero (sin cifras decimales) con signo, que puede valer desde -32768 hasta 32767. Ocupa 2 bytes de memoria. (Nota: el espacio ocupado y los valores que puede almacenar son valores para Turbo Pascal, y pueden variar para otros compiladores).
- Byte. Es un n�mero entero, que puede valer entre 0 y 255. El espacio que ocupa en memoria es el de 1 byte, como su propio nombre indica. (Nota: es un tipo de datos definido por Turbo Pascal, y puede no estar disponible en otros compiladores, como es el caso de GNU Pascal).
- Char. Representa a un car�cter (letra, n�mero o s�mbolo). Ocupa 1 byte.
- String. Es una cadena de caracteres, empleado para almacenar y representar mensajes de m�s de una letra (hasta 255). Ocupa 256 bytes. El formato en Pascal est�ndar (y en Turbo Pascal, hasta la versi�n 3.01) era string[n] (o string(n), seg�n casos, como ya se han comentado), donde n es la anchura m�xima que queremos almacenar en esa cadena de caracteres (de 0 a 255), y entonces ocupar� n+1 bytes en memoria. En las �ltimas versiones de Turbo Pascal (y otros) podemos usar el formato «string[n]» o simplemente «string», que equivale a «string[255]». En otros compiladores, como GNU Pascal, el tama�o permitido es mucho mayor (normalmente por encima de las 32.000 letras).
- Real. Es un numero real (con decimales) con signo. Puede almacenar n�meros con valores entre 2.9e-39 y 1.7e38 (en notaci�n cient�fica, e5 equivale a multiplicar por 10 elevado a 5, es decir, podremos guardar n�meros tan grandes como un 17 seguido de 37 ceros, o tan peque�os como 0,00…029 con 38 ceros detr�s de la coma). Tendremos 11 o 12 d�gitos significativos y ocupan 6 bytes en memoria.
- Boolean. Es una variable l�gica, que puede valer TRUE (verdadero) o FALSE (falso), y se usa para comprobar condiciones.
- Array (nota: algunos autores traducen esta palabra como «arreglo«). Se utilizan para guardar una serie de elementos, todos los cuales son del mismo tipo. Se deber� indicar el �ndice inferior y superior (desde d�nde y hasta d�nde queremos contar), separados por dos puntos (..), as� como el tipo de datos de esos elementos individuales. Por ejemplo, para guardar hasta 200 n�meros enteros, usar�amos:
lista: array[1..200] of integer
Se suele emplear para definir vectores o matrices.
As�, una matriz de dimensiones 3×2 que debiera contener n�meros
reales ser�a:
matriz: array[1..3,1..2] of real
Para mostrar en pantalla el segundo elemento de la primera
lista de n�meros (o de un vector) se usar�a
write( lista[2] );
y para ver el elemento (3,1) de la matriz,
writeln( matriz1[3,1] );
- Record. La principal limitaci�n de un array es que todos
los datos que contiene deben ser del mismo tipo. Pero a veces nos interesa
agrupar datos de distinta naturaleza, como pueden ser el nombre y la edad
de una persona, que ser�an del tipo string y byte, respectivamente.
Entonces empleamos los records o registros, que se definen indicando
el nombre y el tipo de cada campo (cada dato que guardamos en el registro),
y se accede a estos campos indicando el nombre de la variable y el del campo
separados por un punto:
program Record1;
var
dato: record
nombre: string[20];
edad: byte;
end;
begin
dato.nombre:=’Jos� Ignacio’;
dato.edad:=23;
write(‘El nombre es ‘, dato.nombre );
write(‘ y la edad ‘, dato.edad, ‘ a�os.’);
end.
La �nica novedad en la definici�n de la variable
es la aparici�n de una palabra end despu�s de los nombres
de los campos, lo que indica que hemos terminado de enumerar �stos.
Ya dentro del cuerpo del programa, vemos la forma de acceder
a estos campos, tanto para darles un valor como para imprimirlo, indicando el
nombre de la variable a la que pertenecen, seguido por un punto. El conjunto
:= es, como ya hemos dicho, la sentencia de asignaci�n
en Pascal, y quiere decir que la variable que aparece a su izquierda va a tomar
el valor que est� escrito a la derecha (por ejemplo, x := 2 dar�a
el valor 2 a la variable x).
Puede parecer engorroso el hecho de escribir «dato.» antes
de cada campo. Tambi�n hay una forma de solucionarlo: cuando vamos
a realizar varias operaciones sobre los campos de un mismo registro (record),
empleamos la orden with, con la que el programa anterior quedar�a
program Record2;
var
dato: record
nombre: string[20];
edad: byte;
end;
begin
with dato do
begin
nombre:=’Jos� Ignacio’;
edad:=23;
write(‘El nombre es ‘, nombre );
write(‘ y la edad ‘, edad, ‘ a�os.’);
end;
end.
En este caso tenemos un nuevo bloque en el cuerpo del programa,
delimitado por el «begin» y el «end» situados m�s a la derecha, y equivale
a decir «en toda esta parte del programa me estoy refiriendo a la variable
dato». As�, podemos nombrar los campos que queremos modificar o
escribir, sin necesidad de repetir a qu� variable pertenecen.
Nota: aqu� vuelve a aparecer la escritura
indentada: para conseguir una mayor legibilidad, escribimos un poco m�s
a la derecha todo lo que depende de la orden «with». No es algo obligatorio,
pero s� recomendable.
Para mostrar datos, tanto en pantalla como en impresora, se
emplean write y writeln. La diferencia entre ambos
es que «write» deja el cursor en la misma l�nea, a continuaci�n
del texto escrito, mientras que «writeln» baja a la l�nea inferior.
Ambas �rdenes pueden escribir tipos casi de cualquier clase: cadenas
de texto, n�meros enteros o reales, etc. No podremos escribir directamente
arrays, records, ni muchos de los datos definidos por el usuario.
Cuando se desee escribir varias cosas en la misma l�nea,
todas ellas se indican entre un mismo par�ntesis, y separadas por comas.
Un comentario para quien ya haya programado en Basic:
en la mayor�a de las versiones de este lenguaje si separamos varios datos
mediante comas en una sentencia PRINT, se ver�n separados en pantalla
por un cierto n�mero de espacios. En ese aspecto, la «,» de Pascal
recuerda m�s al «;» de Basic, ya que escribe los datos uno a continuaci�n
del otro. De hecho, si fueran n�meros, ni siquiera aparecer�an
espacios entre ellos (tambi�n al contrario que en la mayor�a de
versiones de Basic):
WRITELN (1,10,345); dar�a como resultado
110345.
Se puede especificar la anchura de lo escrito, mediante
el s�mbolo de dos puntos. La cifra que indique la anchura, si se
trata de un n�mero real y queremos indicar tambi�n el n�mero
de decimales, esto se hace tambi�n despu�s de los dos puntos,
con el formato «:anchura_total:decimales». Como ejemplos:
program Write1;
var
nombre: string[40];
edad: byte;
resultado: real;
begin
nombre := ‘Pepe’;
edad := 18;
resultado := 13.12;
write (‘Hola, ‘,nombre,’ qu� tal est�s? ‘);
writeln (resultado:5:2);
writeln(‘Hola,’,nombre:10,’. Tu edad es: ‘,edad:2);
end.
En el caso de una cadena de texto, la anchura que se indica
es la que se tomar� como m�nima: si el texto es mayor no se «parte»,
pero si es menor, se rellena con espacios por la izquierda hasta completar la
anchura deseada.
Igual ocurre con los n�meros: si es m�s grande
que la anchura indicada, no se «parte», sino que se escribe completo.
Si es menor, se rellena con espacios por la izquierda. Los decimales s�
que se redondean al n�mero de posiciones indicado:
program Write2;
var num: real;
begin
num := 1234567.89;
writeln(num);
(* La lnea anterior lo escribe con el formato por defecto:
exponencial *)
writeln(num:20:3); (* Con tres decimales *)
writeln(num:7:2); (* Con dos decimales *)
writeln(num:4:1); (* Con un decimal *)
writeln(num:3:0); (* Sin decimales *)
writeln(num:5); (* Qu hara ahora? *)
end.
La salida por pantalla de este programa ser�a:
1.2345678900E+06
1234567.890
1234567.89
1234567.9
1234568
1.2E+06
Aqu� se puede observar lo que ocurre en los distintos
casos:
- Si no indicamos formato, se usa notaci�n cient�fica (exponencial).
- Si la anchura es mayor, a�ade espacios por la izquierda.
- Si es menor, no se trunca el n�mero.
- Si el n�mero de decimales es mayor, se a�aden ceros.
- Si �ste es menor, se redondea.
- Si indicamos formato pero no decimales, sigue usando notaci�n exponencial,
pero lo m�s compacta que pueda, tratando de llegar al tama�o
que le indicamos.
Para tomar datos del usuario, la forma m�s directa
es empleando readln, que toma un texto o un n�mero y asigna este
valor a una variable. No avisa de lo que est� haciendo, as�
que normalmente convendr� escribir antes en pantalla un mensaje que indique
al usuario qu� esperamos que teclee:
writeln(‘Por favor, introduzca su nombre’);
readln(nombre);
«Readln» tiene algunos inconvenientes:
- No termina hasta que pulsemos RETURN.
- La edici�n es inc�moda: para corregir un error s�lo
podemos borrar todo lo que hab�amos escrito desde entonces, no podemos
usar las flechas o INICIO/FIN para desplazarnos por el texto. - Si queremos dar un valor a una variable num�rica y pulsamos » 23″
(un espacio delante del n�mero) le dar� un valor 0.
En Pascal contamos con una serie de operadores para realizar
sumas, restas, multiplicaciones y otras operaciones no tan habituales:
Operador
Operaci�n
Operandos
Resultado
+
Suma
enteros reales
entero real
–
Resta
enteros reales
entero real
*
Multiplicaci�n
enteros reales
entero real
/
Divisi�n
enteros reales
real
div
Divisi�n entera
enteros
entero
mod
Resto
enteros
entero
En operaciones como +, – y * supongo que no habr� ninguna
duda: si sumo dos n�meros enteros obtengo un n�mero entero, si
resto dos reales obtengo un n�mero real, y lo mismo pasa con la multiplicaci�n.
Los problemas pueden venir con casos como el de 10/3. Si 10 y 3 son n�meros
enteros, qu� ocurre con su divisi�n? En otros lenguajes
como C, el resultado ser�a 3, la parte entera de la divisi�n.
En Pascal no es as�: el resultado ser�a 3.333333, un n�mero
real. Si queremos la parte entera de la divisi�n, deberemos utilizar
div. Finalmente, mod nos indica cual es el resto de la divisi�n.
El signo – se puede usar tambi�n para indicar negaci�n.
Operadores l�gicos
Podremos encadenar proposiciones de ese tipo (si A y B entonces
C) con: and (y), or (�), not (no) y los operadores
relacionales, que se usan para comparar y son los siguientes:
Operador
Operaci�n
=
Igual a
<>
No igual a (distinto de)
<
Menor que
>
Mayor que
<=
Menor o igual que
>=
Mayor o igual que
Igual que antes, algunos de ellos (>=, <=, in) los utilizaremos tambi�n en los conjuntos.
Operaciones entre bits
Los operadores «and», «or» y «not», junto con otros, se pueden utilizar tambi�n para operaciones entre bits de n�meros enteros:
Operador
Operaci�n
not
Negaci�n
and
Producto l�gico
or
Suma l�gica
xor
Suma exclusiva
shl
Desplazamiento hacia la izquierda
shr
Desplazamiento a la derecha
Explicar para qu� sirven estos operadores implica conocer qu� es eso de los bits, c�mo se pasa un n�mero decimal a binario.
Precedencia de los operadores
Para terminar este tema, debemos conocer la precedencia (o prioridad) de los operadores:
Operadores
Precedencia
Categor�a
@ not
Mayor (1)
Operadores unarios
* / div mod
and shl shr
2
Operadores de multiplicaci�n
+ – or xor
3
Operadores de suma
= <> < >
<= >= in
Menor (4)
Operadores relacionales
Esto quiere decir que si escribimos algo como 2+3*4, el ordenador
primero multiplicar� 3*4 (la multiplicaci�n tiene mayor prioridad
que la suma) y luego sumar�a 2 a ese resultado, de modo que obtendr�amos
14. Si queremos que se realice antes la suma, que tiene menor nivel de precedencia,
deber�amos emplear par�ntesis, as�: (2+3)*4.
Condiciones
Vamos a ver c�mo podemos evaluar condiciones desde Pascal.
La primera construcci�n que trataremos es if … then. En
espa�ol ser�a «si … entonces», que expresa bastante bien lo
que podemos hacer con ella. El formato es «if condicion then sentencia«.
program if;
var numero: integer;
begin
writeln(‘Escriba un n�mero’);
readln(numero);
if numero>0 then writeln(‘El n�mero es positivo’);
end.
La «condici�n» debe ser una expresi�n que devuelva
un valor del tipo «boolean» (verdadero/falso). La «sentencia» se
ejecutar� si ese valor es «cierto» (TRUE). Este valor puede ser
tanto el resultado de una comparaci�n.
Condiciones y variables boolean
As�, una forma m�s «rebuscada» (pero que a veces
resultar� m�s c�moda y m�s legible) de hacer lo
anterior ser�a, usando una variable «boolean«:
program if;
var
numero: integer;
esPositivo: boolean;
begin
writeln(‘Escriba un n�mero’);
readln(numero);
esPositivo := (numero>0);
if esPositivo then writeln(‘El n�mero es positivo’);
end.
Condiciones y sentencias compuestas.
La «sentencia» que sigue a «if .. then» puede ser una sentencia
simple o compuesta. Las sentencias compuestas se forman agrupando varias
simples entre un «begin» y un «end»:
program if;
var
numero: integer;
begin
writeln(‘Escriba un n�mero’);
readln(numero);
if numero<0 then
begin
writeln(‘El n�mero es negativo. Pulse
INTRO para seguir.’);
readln
end;
end.
En este ejemplo, si el n�mero es negativo, se ejecutan
dos acciones: escribir un mensaje en pantalla y esperar a que el usuario pulse
INTRO (o ENTER, o RETURN, o <-+, seg�n sea nuestro teclado), lo que
podemos conseguir usando «readln» pero sin indicar ninguna variable en la que
queremos almacenar lo que el usuario teclee.
Si no se cumple la condici�n
Tambi�n podemos indicar lo que queremos que se haga
si no se cumple la condici�n. Para ello tenemos la construcci�n
«if condici�n then sentencia1 else sentencia2″:
program if;
var
numero: integer;
begin
writeln(‘Escriba un n�mero’);
readln(numero);
if numero<0 then
writeln(‘El n�mero es negativo.’)
else
writeln(‘El n�mero es positivo o cero.’)
end.
Un detalle importante que conviene tener en cuenta es que antes
del «else» no debe haber un punto y coma, porque eso indicar�a
el final de la sentencia «if…», y el compilador nos avisar�a con un
error.
Sentencias «If» encadenadas
Las sentencias «if…then…else» se pueden encadenar;
program if;
var
numero: integer;
begin
writeln(‘Escriba un n�mero’);
readln(numero);
if numero<0 then
writeln(‘El n�mero es negativo.’)
else if numero>0 then
writeln(‘El n�mero es positivo.’)
else
writeln(‘El n�mero es cero.’)
end.
Varias condiciones simult�neas
Si se deben cumplir varias condiciones a la vez, podemos
enlazarlas con «and» (y). Si se pueden cumplir varias, usaremos
«or» (o). Para negar, «not» (no):
if ( opcion = 1 ) and ( terminado = true ) then […]
if ( opcion = 3 ) or ( teclaPulsada = true ) then […]
if not ( preparado ) then […]
if ( opcion = 2 ) and not ( nivelDeAcceso < 40 ) then […]
Pero cuando queremos comprobar entre varios posibles valores,
ser�a muy pesado tener que hacerlo con muchos «if» seguidos o encadenar
muchos con «and» u «or».. Hay una alternativa que resulta mucho m�s
c�moda: la orden case.
Su sintaxis es:
case expresi�n of
caso1: sentencia1;
caso2: sentencia2;
…
casoN: sentenciaN;
end;
O bien, si queremos indicar lo que se debe hacer si no coincide
con ninguno de los valores que hemos enumerado, usamos else:
case expresi�n of
caso1: sentencia1;
caso2: sentencia2;
…
casoN: sentenciaN;
else
otraSentencia;
end;
En Pascal est�ndar, esta construcci�n se empleaba con
otherwise en lugar de «else» para significar «en caso contrario», as�
que si alguien de los que me lee no usa TP/BP, sino un compilador que protesta
con el «else»
program case;
var
letra: char;
begin
WriteLn(‘Escriba un s�mbolo’);
ReadLn(letra);
case letra of
‘ ‘:
WriteLn(‘Un espacio’);
‘A’..’Z’, ‘a’..’z’: WriteLn(‘Una letra’);
‘0’..’9′:
WriteLn(‘Un d�gito’);
‘+’, ‘-‘, ‘*’, ‘/’: WriteLn(‘Un operador’);
else { otherwise en SURPAS }
WriteLn(‘No es espacio, ni letra, ni d�gito,
ni operador’);
end;
end.
La «expresi�n» debe pertenecer a un tipo de datos con
un n�mero finito de elementos, como «integer» o «char», pero no
«real».
Y como se ve en el ejemplo, los «casos» posibles pueden
ser valores �nicos, varios valores separados por comas, o un rango de
valores separados por .. (como los puntos suspensivos, pero s�lo dos,
al igual que en los «arrays»).,
Constantes y tipos
Definici�n de constantes
Cuando desarrollamos un programa, nos podemos encontrar con
que hay variables que realmente «no var�an» a lo largo de la ejecuci�n
de un programa, sino que su valor es constante.
Hay una manera especial de definirlas, que es con el especificador
«const«, que tiene el formato
const Nombre = Valor;
Veamos un par de ejemplos antes de seguir
const MiNombre = ‘Nacho Cabanes’;
const PI = 3.1415926535;
const LongitudMaxima = 128;
Estas constantes se manejan igual que variables como las que
hab�amos visto hasta hora, s�lo que no se puede cambiar su valor.
As�, es valido hacer
Writeln(MiNombre);
if Longitud > LongitudMaxima then …
OtraVariable := MiNombre;
LongCircunf := 2 * PI * r;
pero no podr�amos hacer
PI := 3.14;
MiNombre := ‘Nacho’;
LongitudMaxima := LongitudMaxima + 10;
Constantes «con tipo»
El identificador «const» tiene tambi�n en Turbo Pascal
otro uso menos habitual: definir lo que se suele llamar constantes con tipo,
que son variables normales y corrientes, pero a las que damos un valor
inicial antes de que comience a ejecutarse el programa. Se usa
const variable: tipo = valor;
As�, volviendo al ejemplo de la clave de acceso,
pod�amos tener una variables «intentos» que dijese el n�mero de
intentos. Hasta ahora habr�amos hecho
var
intentos: integer;
begin
intentos := 3;
…
Ahora ya sabemos que ser�a mejor hacer, si sabemos que
el valor no va a cambiar:
const
intentos = 3;
begin
…
Pero si se nos da el caso de que vemos por el nombre que es
alguien de confianza, que puede haber olvidado su clave de acceso, quiz�
nos interese permitirle 5 o m�s intentos. Qu� hacemos?
Ya no podemos usar «const» porque el valor puede variar, pero por otra parte,
siempre comenzamos concediendo 3 intentos, hasta comprobar si es alguien de
fiar. Conclusi�n: podemos hacer
const intentos: integer = 3;
begin
…
Insisto: una «constante con tipo» es exactamente igual que
una variable, con las ventajas de que est� m�s f�cil
de localizar si queremos cambiar su valor inicial y de que el compilador optimiza
un poco el c�digo, haciendo el programa unos bytes m�s peque�o.
Definici�n de tipos
El «tipo» de una variable es lo que determina qu� clase
de valores podremos guardar en ella. Para nosotros, es lo que indicamos junto
a su nombre cuando la declaramos. Por ejemplo,
var PrimerNumero: integer;
Indica que vamos a usar una variable que se va a llamar PrimerNumero
y que almacenar� valores de tipo entero. Si queremos definir
una de las fichas de lo que ser� nuestra agenda, tambi�n har�amos:
var ficha: record
nombre: string;
direccion: string;
edad: integer;
observaciones: string
end;
Procedimientos y funciones
La programaci�n estructurada trata de
dividir el programa el bloques m�s peque�os, buscando una mayor
legibilidad, y m�s comodidad a la hora de corregir o ampliar.
Por ejemplo, en el caso de nuestra maravillosa agenda, podemos empezar a teclear
directamente y crear un programa de 2000 l�neas que quiz�s incluso
funcione, o dividirlo en partes, de modo que el cuerpo del programa sea
begin
InicializaVariables;
PantallaPresentacion;
Repeat
PideOpcion;
case Opcion of
‘1’: MasDatos;
‘2’: CorregirActual;
‘3’: Imprimir;
…
end;
Until Opcion = OpcionDeSalida;
GuardaCambios;
LiberaMemoria
end.
En nuestro caso (en el lenguaje Pascal), estos bloques ser�n
de dos tipos:
procedimientos (procedure) y funciones (function).
La diferencia entre ellos es que un procedimiento ejecuta una serie de
acciones que est�n relacionadas entre s�, y no devuelve ning�n
valor, mientras que la funci�n s� que va a devolver valores.
Veamoslo con un par de ejemplos:
procedure Acceso;
var
clave: string;
(* Esta variable es local *)
begin
writeln(‘ Bienvenido a SuperAgenda ‘);
writeln(‘==========================’); (* Para subrayar *)
writeln; writeln;
(* Dos l�neas en blanco *)
writeln(‘Introduzca su clave de acceso’);
readln( clave );
(* Lee un valor *)
if clave <> ClaveCorrecta then
(* Compara con el correcto *)
begin
(* Si no lo es *)
writeln(‘La clave no es correcta!’); (* avisa y *)
exit
(* abandona el programa *)
end
end;
El cuerpo de un procedimiento se encierra entre «begin»
y «end», igual que las sentencias compuestas y que el propio cuerpo del programa.
Un procedimiento puede tener sus propias variables, que llamaremos
variables locales, frente a las del resto del programa, que son globales.
Desde dentro de un procedimiento podemos acceder a las variables globales (como
ClaveCorrecta del ejemplo anterior), pero desde fuera de un procedimiento no
podemos acceder a las variables locales que hemos definido dentro de �l.
La orden exit, que no hab�amos visto a�n, permite interrumpir
la ejecuci�n del programa (o de un procedimiento) en un determinado momento.
Veamos el segundo ejemplo: una funci�n que eleve
un n�mero a otro (esa posibilidad no existe «de forma nativa» en Pascal),
se podr�a hacer as�, si ambos son enteros:
function potencia(a,b: integer): integer; (* a elevado a b *)
var
i: integer;
(* para bucles *)
temporal: integer;
(* para el valor temporal *)
begin
temporal := 1;
(* incializaci�n *)
for i := 1 to b do
temporal := temporal * a; (*
hacemos «b» veces «a*a» *)
potencia := temporal;
(* y finalmente damos el valor *)
end;
Esta funci�n se llama «potencia».
Tiene dos par�metros llamados «a» y «b» que son
n�meros enteros (valores que «se le pasan» a la funci�n para que
trabaje con ellos).
El resultado va a ser tambi�n un n�mero entero.
«i» y «temporal» son variables locales: una para el bucle «for»
y la otra almacena el valor temporal del producto.
Antes de salir es cuando asignamos a la funci�n el que
ser� su valor definitivo.
Robert Da Corte
 P�gina anterior | Volver al principio del trabajo | P�gina siguiente  |