15.1. Procedimientos.
Hemos visto cómo hacer que se repita un bloque de programa, usando
estructuras como "for", "while" o "repeat". Pero cuando un fragmento de
programa se debe repetir en varias partes de nuestro fuente, el resultado
puede seguir siendo redundante. Por ejemplo, podemos escribir varias
frases "subrayadas" con asterisco así:
(* [Link], procedimientos: acercamiento *)
(* Curso de Pascal, por Nacho Cabanes *)
program Proc01;
var
i: byte;
begin
{ Primer texto }
writeLn( 'Primer texto' );
{ Escribimos 20 asteriscos y avanzamos de linea }
for i := 1 to 20 do
write('*');
writeLn;
{ Segundo texto }
writeLn( 'Y un segundo texto' );
{ Escribimos 20 asteriscos y avanzamos de linea }
for i := 1 to 20 do
write('*');
writeLn;
{ Tercer texto }
writeLn( 'Texto de despedida' );
{ Escribimos 20 asteriscos y avanzamos de linea }
for i := 1 to 20 do
write('*');
writeLn;
end.
(*
Resultado:
Primer texto
********************
Y un segundo texto
********************
Texto de despedida
********************
*)
Esto es claramente repetitivo. Podemos crear un "bloque" llamado
"Escribir20asteriscos" y que sirva como una "abreviatura" que nos
permita no tener que teclear tantos código repetitivo. Además, el repetir
menos hace que el programa sea menos propenso a errores, ya sea en
el momento de teclear o cuando vayamos a ampliarlo o corregirlo (por
ejemplo, si queremos cambiar los 20 asteriscos por 18, corremos el
riesgo de olvidar hacerlo en alguno de los bloques). Quedaría así:
(* [Link], procedimientos: uso real *)
(* Curso de Pascal, por Nacho Cabanes *)
program Proc02;
procedure Escribir20asteriscos;
var
i: byte;
begin
{ Escribimos 20 asteriscos y avanzamos de linea }
for i := 1 to 20 do
write('*');
writeLn;
end;
begin
writeLn( 'Primer texto' );
Escribir20asteriscos;
writeLn( 'Y un segundo texto' );
Escribir20asteriscos;
writeLn( 'Texto de despedida' );
Escribir20asteriscos;
end.
(*
Resultado:
Primer texto
********************
Y un segundo texto
********************
Texto de despedida
********************
*)
Estos bloques, que llamaremos "procedimientos" (y que en otros
lenguajes de programación se conocen como "subrutinas") ayudarán a
que nuestro programa sea menos repetitivo y resulte más fácil de leer.
En este programa, "i" es una variable local: se declara dentro del
procedimiento "Escribir20asteriscos" y sólo es accesible dentro de él. Si
en el cuerpo del programa intentamos hacer algo como "i:=2;" el
programa no compilará, porque la variable no existe en esa zona.
Debemos buscar conseguir que tantas variables como podamos sean
locales. Sólo deberán ser "globales" (compartidas por todo el programa,
y declaradas fuera de procedimientos) las variables que realmente se
vayan a utilizar desde varias zonas distintas.
15.2. Procedimientos con parámetros.
La verdadera potencia de los procedimientos está en que no tienen por
qué trabajar siempre con los mismos datos, sino que podemos indicarles
unos datos adicionales, que llamaremos parámetros. Por ejemplo,
podemos mejorar el procedimiento que escribía asteriscos, si le
indicamos la cantidad de asteriscos que debe mostrar en pantalla, así:
(* [Link], procedimientos con parametros *)
(* Curso de Pascal, por Nacho Cabanes *)
program Proc03;
procedure EscribirAsteriscos( cantidad: integer );
var
i: byte;
begin
{ Escribimos N asteriscos y avanzamos de linea }
for i := 1 to cantidad do
write('*');
writeLn;
end;
begin
writeLn( 'Primer texto' );
EscribirAsteriscos(12);
writeLn( 'Y un segundo texto' );
EscribirAsteriscos(18);
writeLn( 'Y texto de despedida' );
EscribirAsteriscos(20);
end.
(*
Resultado:
Primer texto
************
Y un segundo texto
******************
Y texto de despedida
********************
*)
15.3. Funciones
En muchas ocasiones querremos obtener un valor como resultado de
esa "subrutina" que hemos creado. Llamaremos "función" a un
procedimiento capaz de devolver un valor. Por ejemplo, podríamos crear
una función sencilla, que calcule (y devuelva) el doble del número que se
le pase como parámetro, así:
(* [Link], Primer ejemplo de funcion *)
(* Curso de Pascal, por Nacho Cabanes *)
program FuncionDoble;
function doble( numero: integer): integer;
begin
doble := numero * 2;
end;
(* Cuerpo del programa *)
var
n: integer;
begin
write('Introduce un numero entero: ');
readLn( n );
writeLn('Su doble es: ', doble(n) );
writeLn('Y el doble de 5 es: ', doble(5) );
end.
(*
Ejemplo de ejecucion:
Introduce un numero entero: 3
Su doble es: 6
Y el doble de 5 es: 10
*)
Aquí hay varios detalles que merece la pena comentar, algunos de ellos
nuevos:
Esta función se llama "doble".
Tiene un parámetro llamado "numero", que es un número entero.
El resultado va a ser también un número entero.
Antes de salir de la función, le asignamos el que será su valor
definitivo.
Desde el cuerpo del programa usamos la función 2 veces: la
primera para calcular el doble del número "n", que ha introducido el
usuario, y la segunda para hallar el doble de 5.
Una función puede recibir más de un parámetro, y puede realizar
operaciones más complejas. Por ejemplo, podríamos calcular una
potencia (un número elevado a otro) mediante multiplicaciones
repetitivas, así:
(* [Link], Segundo ejemplo de funcion *)
(* Curso de Pascal, por Nacho Cabanes *)
program PruebaDePotencia;
function potencia(a,b: integer): integer; (* Definimos la funcion *)
var
i: integer; (* Locales: para bucles *)
temporal: integer; (* y para el valor temporal *)
begin
temporal := 1; (* Inicializacion *)
for i := 1 to b do
temporal := temporal * a; (* multiplicamos "b" veces por "a" *)
potencia := temporal; (* y finalmente devolvemos el valor *)
end;
var
numero1, numero2: integer;
begin (* Cuerpo del programa *)
writeLn('Potencia de un numero entero');
writeLn;
writeLn('Introduce el primer numero');
readLn( numero1 );
writeLn('Introduce el segundo numero');
readLn( numero2 );
writeLn( numero1 ,' elevado a ', numero2 ,' vale ',
potencia (numero1, numero2) )
end.
Ejercicio propuesto 15.1.1: Crea un procedimiento llamado
"Escribir10guiones", que escriba 10 guiones (el símbolo de la resta) en
pantalla. Empléalo en un programa.
Ejercicio propuesto 15.1.2: Crea un procedimiento llamado
"DibujarRectanguloAsteriscos", que muestre en pantalla un rectángulo de
10 asteriscos de ancho y 5 de alto. Utilízalo en un programa.
Ejercicio propuesto 15.1.3: Crea un procedimiento "EscribirVector",
que escriba en pantalla los datos de un vector de números reales de 3
elementos. Los datos deben aparecer separados por comas, y debe
haber un paréntesis abierto antes del primer dato y un paréntesis cerrado
tras el tercer dato. El vector a mostrar será una variable global llamada
"datos". Aplícalo a un programa que pida los datos al usuario y luego los
muestre.
Ejercicio propuesto 15.2.1: Crea un procedimiento llamado
"EscribirGuiones", que escriba en pantalla tantos guiones como se
indique como parámetro. Empléalo en un programa.
Ejercicio propuesto 15.2.2: Crea un procedimiento llamado
"DibujarRectanguloAsteriscos", que muestre en pantalla un rectángulo de
asteriscos, del ancho y alto que se indiquen como parámetros. Utilízalo
en un programa.
Ejercicio propuesto 15.2.3: Crea un procedimiento "EscribirVector",
que escriba en pantalla los datos de un vector de números reales de 3
elementos. El vector se pasará al procedimiento como parámetro. Los
datos deben aparecer separados por comas, y debe haber un paréntesis
abierto antes del primer dato y un paréntesis cerrado tras el tercer dato.
Ejercicio propuesto 15.3.1: Crea una función "triple", que reciba un
número real como parámetro, y devuelva como resultado ese número
multiplicado por tres.
Ejercicio propuesto 15.3.2: Prepara una función llamada "media", que
reciba dos números reales como parámetros, y devuelva como resultado
su media aritmética.
Ejercicio propuesto 15.3.3: Crear una función "potenciaReal", que
trabaje con números reales, y permita cálculos como 3.2 elevado a 1.7
(pista; hay que usar exponenciales y logaritmos, como vimos en el
apartado 1.6.3
Ejercicio propuesto 15.3.4: Haz una función que halle la raíz cúbica del
número que se le indique (pista: hallar una raíz cúbica es lo mismo que
elevar a 1/3).
Ejercicio propuesto 15.3.5: Define las funciones Suma3 y Producto3,
que calculen suma y producto de tres números enteros, y crea un
programa que haga una operación u otra según escoja el usuario
(empleando "case").
Por supuesto, una función puede devolver valores de otros tipos, no solo
numéricos. Así, una función que nos devolviera la inicial de una palabra
podría ser:
(* [Link], Funcion que devuelve char *)
(* Curso de Pascal, por Nacho Cabanes *)
program FuncionInicial;
function inicial( texto: string): char;
begin
inicial := texto[1];
end;
(* Cuerpo del programa *)
var
frase: string;
begin
write('Introduce una frase: ');
readLn( frase );
writeLn('Su primera letra es: ', inicial(frase) );
end.
(*
Ejemplo de ejecucion:
Introduce una frase: hola, que tal
Su primera letra es: h
*)
O bien podríamos recorrer una frase formada por varias palabras, para
así construir y devolver una cadena que contenga las iniciales de todas
ellas:
(* [Link], Funcion que devuelve un string *)
(* Curso de Pascal, por Nacho Cabanes *)
program FuncionIniciales;
function iniciales( texto: string): string;
var
temporal: string;
i: byte;
begin
temporal := '';
temporal := temporal + texto[1];
for i := 2 to length(texto) do
if texto[i-1] = ' ' then
temporal := temporal + texto[i];
iniciales := temporal;
end;
(* Cuerpo del programa *)
var
frase: string;
begin
write('Introduce una frase con varias palabras: ');
readLn( frase );
writeLn('Sus iniciales son: ', iniciales(frase) );
end.
(*
Ejemplo de ejecucion:
Introduce una frase con varias palabras: hola, que tal
Sus iniciales son: hqt
*)
