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 siguiente |