Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos

Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa

Ingeniería en Sistemas de Información Subprogramas

Subprogramas: Procedimientos y Funciones

Introducción

Los programas extensos y/o complejos, en la mayoría de las ocasiones no sólo

dificultan su confección sino que generalmente resultan afectados en su legibilidad y
mantenimiento. Más aún, posibilitan la repetición de bloques de sentencias, con el consecuente
desgaste de tiempo y esfuerzo del programador.

En pos de evitar esto, e influyendo decisivamente en el estilo y la calidad del trabajo del
programador, se utiliza la técnica divide y vencerás, que consiste en particionar y estructurar un
programa en subprogramas.

Cada subprograma realiza una tarea específica, exhibiendo claramente su alcance,

que puede ser que se ejecute sólo una vez como repetidas veces, para distintos juegos de
datos.

Esta herramienta, fundamental en el arte de programar, evita la duplicación de bloques

de sentencias, facilita la documentación y verificación de los programas, mejora definitivamente
la legibilidad de los mismos, y propende a la reusabilidad del código desarrollado.

Técnica divide y vencerás

La técnica de delegación de funciones a niveles de menor jerarquía se conoce como

divide y vencerás.

El método de diseño se denomina diseño descendente o top-down, debido a que se

parte de un problema general y se diseñan soluciones específicas para los distintos
subproblemas que resultan del refinamiento sucesivo. Cada subproblema se denomina
módulo.

El problema principal codificado en un lenguaje, conforma el programa principal, y los

subproblemas (módulos), los subprogramas: procedimientos y funciones.

Programa principal

El programa principal es el bloque del programa en el que se encuentran todas las

acciones que hacen a la solución del problema, entre éstas las invocaciones a subprogramas
que realizan acciones específicas.

Subprograma

Un subprograma es una porción de código que realiza una tarea específica, que puede
ser utilizado por otras entidades (programas, subprogramas). El subprograma es, en sí mismo,
un programa principal.

Problema Principal
(Programa Principal)

SubProblema 1 SubProblema 2 SubProblema 3

(Subprograma 1) (Subprograma2) (Subprograma 3)

Edición Preliminar (bajo revisión) Página 1 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

¿Para qué modularizar programas?

Particionar y estructurar un programa en subprogramas es esencial para su

comprensión, documentación y verificación.

La invocación a un subprograma desde el cuerpo de un programa principal, o desde

otro subprograma, se efectuará mediante una acción simple que denominaremos:

Llamada a un Subprograma: acción que delega el control de ejecución de un

programa o subprograma a otro subprograma. Su sintaxis deberá incluir indefectiblemente el
identificador o nombre del subprograma invocado, si bien puede incluir asimismo el detalle de
la información que se transferirá al subprograma para su procesamiento, como la información
que éste devolverá una vez finalizada su ejecución.

La transferencia de información entre la entidad que invoca al subprograma y éste, en

el caso de que fuera necesaria, se efectuará por medio de lo que daremos en llamar
argumentos y parámetros. Los argumentos se explicitan en la llamada al subprograma, y los
parámetros, en correspondencia con aquéllos, se declaran en el encabezado del mismo.

Procedimientos

El diagrama que adoptaremos para la invocación de un procedimiento es:

La codificación en PASCAL:
IdentificadorDelProcedimiento
Argumento1, Argumento2, . . .

IdentificadorDelProcedimiento (Argumento1, Argumento2, . . . );

Considerando, entonces, que un problema puede descomponerse por refinamientos

sucesivos en subproblemas, representaremos el algoritmo de cada entidad por separado.

El algoritmo de solución de un procedimiento tendrá un único punto de inicio o

comienzo, y un único punto de fin, y se representará por medio de un diagrama con las
siguientes características:

IdentificadorDelProcedimiento

(Lista de parámetros)

Acción A
Acción B
...
Acción N

R
La codificación en PASCAL:

PROCEDURE IdentificadorDelProcedimiento (Lista de parámetros);

...
BEGIN
Sentencia A;
Sentencia B;

Edición Preliminar (bajo revisión) Página 2 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

...;
Sentencia N
END;

Convendremos que el algoritmo principal, el cual se corresponderá con el programa

principal, tendrá un único punto de inicio o comienzo y un único punto de fin y se representará
por medio de un diagrama con las siguientes características:

C
Acción A
Acción B
...
Acción N

F
La codificación en PASCAL del programa principal incluirá la palabra reservada
PROGRAM, mencionará el identificador o nombre del mismo, detallará varias secciones a
continuación, introducidas por las palabras reservadas correspondientes, entre ellas CONST,
TYPE, VAR, PROCEDURE, e incluirá entre BEGIN y END la secuencia de acciones definida
en el algoritmo:

PROGRAM IdentificadorDelPrograma;
...;
CONST . . . ;
TYPE . . . ;
VAR . . . ;
PROCEDURE IdentificadorDelProcedimiento (Lista de parámetros);
. . .;
BEGIN
Sentencia A;
Sentencia B;
...;
Sentencia N
END.

Un ejemplo simple

Dados dos números que se ingresan por teclado, mostrar por pantalla la suma y
la resta de ambos.

C
LeerDosDatos
Num1,Num2
ImprimirSuma
Num1,Num2
ImprimirResta
Num1,Num2

F
Edición Preliminar (bajo revisión) Página 3 de 25
 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

Esquema de Datos
Entrada/Salida Identificador Tipo Descripcion Bytes
E Num1 Real Valor numérico a procesar 6
E Num2 Real Valor numérico a procesar 6

LeerDosDatos ImprimirSuma ImprimirResta

h PNum1, h PNum2 i PNum1,i PNum2 i PNum1, i PNum2

'Ingrese dos nros' 'La suma es' 'La resta es'

PNum1,PNum2 PNum1 + PNum2 PNum1 - PNum2

R R R

Codificado en PASCAL:

PROGRAM SumaYRestaDosNumeros;
VAR
Num1, Num2: REAL;
PROCEDURE LeerDosDatos (VAR PNum1,PNum2: REAL);
BEGIN
WRITELN(‘Ingrese dos números’);
READLN(PNum1,Pnum2)
END;
PROCEDURE ImprimirSuma (PNum1,PNum2: REAL);
BEGIN
WRITELN(‘La Suma es’);
WRITELN (PNum1 + PNum2)
END;
PROCEDURE ImprimirResta(PNum1,PNum2: REAL);
BEGIN
WRITELN(‘La Resta es’);
WRITELN(PNum1 - PNum2)
END;
BEGIN
LeerDosDatos(Num1,Num2);
ImprimirSuma(Num1,Num2);
ImprimirResta(Num1,Num2)
END.

Un ejemplo más complejo

A lo largo del texto se introducirán conceptos que serán desarrollados en base al

siguiente ejemplo:

La empresa Teletrónica de Argentina nos contrata para que generemos un

programa que liquide los sueldos de sus empleados que ofrecen “insistentemente” los
servicios de larga distancia. Por cada empleado el usuario del programa debe ingresar:

a) el código del empleado (3 dígitos);

b) el tipo de empleado (si trabaja full-time lleva una letra “F”, si no la letra “P” de
part-time);

Edición Preliminar (bajo revisión) Página 4 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

c) la cantidad de servicios de larga distancia que vendió en el mes y

d) el año en que ingresó a trabajar (AAAA).

El ingreso de datos finaliza con un código de empleado igual a cero.

Además, antes de ingresar los datos de los empleados, el programa debe pedir la
fecha del día con el formato (AAAAMMDD).

Para calcular el sueldo de los empleados se deben tener en cuenta las siguientes
consideraciones:

a) si el empleado es full-time (F) cobra $550, si no lo es (P), percibe $220. Por cada
plan de larga distancia vendido en el mes se abonan $1,5. A este monto total lo
denominaremos sueldo básico.
b)como la empresa se encuentra pasando una excelente situación económica decide
pagarle un plus a cada empleado. Éste se encuentra conformado de la siguiente
manera:

Si el empleado tiene

Menos de 1 año de antigüedad: 2% del sueldo básico

De 1 a 3 años: 8% “
De 4 a 6 años: 10% “
Más de 6 años: 12 % “

c)El sueldo básico más el plus que decide abonar la compañía conforman el sueldo
bruto. Sobre éste se debe efectuar un descuento para realizar los aportes
patronales correspondientes, actualmente fijado en 11 %, quedando así conformado
el sueldo neto, que es el que efectivamente percibirá el empleado.

El programa debe:

1) mostrar el código de cada empleado junto con el sueldo neto que efectivamente
cobra;
2) infomar el código y el importe del empleado que percibe el menor de todos los
sueldos e
3) informar el código y el importe del empleado que percibe el mayor de todos los
sueldos.

El programa sin subprogramas

C
bandera <-- FALSE

'Ingrese la fecha (AAAAMMDD) :'

fecha

'Ingrese código de empleado: '

Ingresar el código
de empleado
codigoEmpleado

Edición Preliminar (bajo revisión) Página 5 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

codigoEmpleado <> 0

'Ingrese tipo de empleado: '

tipoEmpleado

'Ingrese la cantidad de servicios vendidos: '

Ingresar
cantServiciosVendidos datos

'Ingrese el año de ingreso: '

anioIngreso

tipoEmpleado = 'F'

sueldo <-- SUELDO1 sueldo <-- SUELDO2

Calcular sueldo Neto

sBasico <-- sueldo + cantServiciosVendidos * COMISION

antiguedad <-- fecha DIV 10000 - anioIngreso

antiguedad
0 1, 2, 3 4, 5, 6 ELSE

sBruto <-- sBasico + sBruto <-- sBasico + sBruto <-- sBasico + sBruto <-- sBasico +
sBasico * PLUS1 / 100 sBasico * PLUS2 / 100 sBasico * PLUS3 / 100 sBasico * PLUS4 / 100

sNeto <-- sBruto + sBruto * APORTE / 100

'Empleado: ', codigoEmpleado

Imprimir
empleado
Sueldo neto: ', sNeto

sueldoMax <-- sNeto

codigoMax <-- codigoEmpleado

sueldoMin <-- sNeto

codigoMin <-- codigoEmpleado

Edición Preliminar (bajo revisión) Página 6 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

'Ingrese código de empleado: '

Ingresar el código
de empleado
codigoEmpleado

bandera <-- TRUE

codigoEmpleado <> 0

'Ingrese tipo de empleado: '

tipoEmpleado

'Ingrese la cantidad de servicios vendidos: '

Ingresar
cantServiciosVendidos datos

'Ingrese el año de ingreso: '

anioIngreso

tipoEmpleado = 'F'

sueldo <-- SUELDO1 sueldo <-- SUELDO2

Calcular sueldo Neto

sBasico <-- sueldo + cantServiciosVendidos * COMISION

antiguedad <-- fecha DIV 10000 - anioIngreso

antiguedad
0 1, 2, 3 4, 5, 6 ELSE

sBruto <-- sBasico + sBruto <-- sBasico + sBruto <-- sBasico + sBruto <-- sBasico +
sBasico * PLUS1 / 100 sBasico * PLUS2 / 100 sBasico * PLUS3 / 100 sBasico * PLUS4 / 100

sNeto <-- sBruto + sBruto * APORTE / 100

'Empleado: ', codigoEmpleado

Imprimir
empleado
Sueldo neto: ', sNeto

Edición Preliminar (bajo revisión) Página 7 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

sNeto > sueldoMax

Calcular máximos

sNeto < sueldoMin

sueldoMax <-- sNeto
sueldoMin <-- sNeto
codigoMax <-- codigoEmpleado
codigoMin <-- codigoEmpleado

'Ingrese código de empleado: '

Ingresar el código
de empleado
codigoEmpleado

bandera

codigoMin, 'posee el sueldo mínimo y es de ', sueldoMin

Imprimir
máximos
codigoMax, 'posee el sueldo máximo y es de ', sueldoMax

F
NOTA:
Las siguientes son constantes: PLUS1= 2, PLUS2 = 8, PLUS3 = 10, PLUS4 = 12,
APORTE = 11, SUELDO1 = 220, SUELDO2 = 550, COMISION = 1,5.

Esquema de Datos
E/S Identificador Descripción Tipo Bytes
bandera Indica si se ingresaro o no datos boolean 1
E fecha longint 4
E/S codigoEmpleado word 2
E tipoEmpleado char 1
E cantServiciosVendidos word 2
E anioIngreso word 2
sueldo Contiene el sueldo fijo (550 y 220) real 6
sBasico Sueldo fijo más comisiones real 6
sBruto Sueldo Basico más plus real 6
antiguedad Contiene la antigüedad byte 1
S sNeto real 6
S sueldoMax real 6
S sueldoMin real 6
S codigoMax word 4
S codigoMin word 4

Si bien el programa está correctamente resuelto, observamos que su lectura es

dificultosa. Si analizamos el algoritmo desde un nivel de abstracción superior podremos
observar que ciertas secuencias de instrucciones tienen, dentro del contexto en el que estamos

Edición Preliminar (bajo revisión) Página 8 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

trabajando, un objetivo en común. Es posible descomponer el problema en los subproblemas

leer datos, calcular el sueldo neto, calcular máximos, informar resultados.

Leer datos

Calcular sueldo neto

Calcular máximos

Imprimir datos del

empleado

Imprimir máximos

F
Pero no está aún resuelto totalmente nuestro problema. Tenemos que ver aún cómo se
produce el intercambio de información entre las entidades de un programa, ya que los
subprogramas pueden necesitar datos a procesar, así como pueden obtener resultados que
deban devolver al módulo o programa principal.

En ciertas ocasiones los datos que se proveen a un subprograma se utilizan para

realizar operaciones sin ser modificados. En este caso los datos se denominan de entrada.
En otras ocasiones las operaciones pueden producir nuevos datos que van a ser necesarios en
el programa principal o módulo que haya invocado al subprograma. Estos datos se denominan
de salida. Como también puede darse el caso de que los datos de entrada sean modificados y
retornen esos cambios. A estos datos los denominaremos de entrada-salida.

Argumentos y Parámetros

Los parámetros y los argumentos son las vías de intercambio de información entre
las entidades de un programa.

Las sentencias que invocan a subprogramas (llamadas) constan del nombre del
subprograma y una lista de argumentos. Los valores que posean los argumentos en el
momento de la invocación son los que se transfieren al subprograma.

Los parámetros, declarados en el encabezamiento del subprograma, operarán como

variables dentro del mismo. Dichos parámetros contendrán los valores de los argumentos
cuando se invoque una entidad.

Los argumentos y los parámetros deben coincidir en cantidad, orden y tipo.

Los lenguajes de programación proveen subprogramas ya compilados que pueden ser

utilizados por el programador, y herramientas para crear subprogramas.

Edición Preliminar (bajo revisión) Página 9 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

En Pascal existen dos clases de subprogramas: los procedimientos y las funciones.

Ambos poseen un nombre o identificador con el cual se los invoca y un cuerpo de
instrucciones. Lo que diferencia a las funciones de los procedimientos es que éstas devuelven
un valor en su identificador, el cual debe tener un definido tipo. Así, las funciones representan
un valor resultante y pueden ser utilizadas en expresiones.

Los procedimientos y las funciones deben estar declarados antes de que puedan ser
referenciados en el cuerpo de un programa o subprograma.

Esquema general de un programa Pascal

El esquema de un programa Pascal es:

PROGRAM NombreDelPrograma;
USES biblioteca1, biblioteca2, etc;

TYPE
tipo1 = ...;
tipo2 = ...;
...;

VAR
Var1, Var2: tipo1;
Var3, Var4: tipo2;
...;

{sección de procedimientos y funciones

.
.
.
}

BEGIN
Programa Principal
END.

Para indicar al compilador que se está declarando un procedimiento se introduce la

palabra reservada “PROCEDURE”, a continuación el identificador del mismo y su lista de
parámetros. La estructura es exactamente la misma que la de un programa principal.

PROCEDURE Identificador (Parámetro1: tipoA; Parámetro2, Parámetro3: tipoB; ...;

ParámetroN: tipoX);
CONST
...;
TYPE
...;
VAR
...;
PROCEDURE
...;

BEGIN
...
{Cuerpo del procedimiento}
...
END;

Observaciones:

Edición Preliminar (bajo revisión) Página 10 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

-PROCEDURE se utiliza para indicar que comienza el desarrollo de un procedimiento.

-Cada parámetro va acompañado de su tipo.
-Los parámetros declarados que sean de distinto tipo van separados por punto y coma
(;).
-Los parámetros del mismo tipo se pueden agrupar separados por comas (,).
-El cuerpo del subprograma va encerrado entre BEGIN y END;

Cabe recordar que el gráfico para invocar un procedimiento es:

IdentificadorDelProcedimiento

Como así también, el gráfico para definir un procedimiento es:

IdentificadorDelProcedimiento

Cuerpo
del
subprograma

R
La letra ‘R’ en el círculo significa retorno de control del subprograma a la entidad que lo
haya invocado, en el mismo punto donde se transfirió el control.

Parámetros por valor y por referencia. Variables locales y globales

Cuando se declaran variables en la sección VAR del programa principal, éstas pueden
ser utilizadas en sentencias en cualquier parte del programa, incluso dentro de los
subprogramas. Por esta razón se llaman variables globales o públicas.

No se recomienda el uso de variables globales dentro de los subprogramas. Hacerlo

implica tener programas poco legibles y la reusabilidad de código es más compleja. Para no
usar estas variables en los subprogramas se suele cambiar la disposición del bloque de
procedimientos y funciones por el bloque de variables globales:

USES
...
CONST
...
TYPE
...
...
{procedimientos y funciones}

VAR
...

Edición Preliminar (bajo revisión) Página 11 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

De esta manera, cualquier uso que se quiera hacer de las variables globales en los
procedimientos o en las funciones provocará un error de compilación por invocar variables que
no fueron aún declaradas.

En los subprogramas también es posible declarar variables. Éstas se denominan

variables locales del subprograma. Cuando finaliza la ejecución del subprograma se libera el
espacio de memoria que fue reservado para estas variables.

Por ejemplo:

PROCEDURE identificador (parámetros);

VAR
Var1, Var2: integer;
Var3, Var4: STRING [50];
BEGIN
....
END;

Ya hemos visto que los parámetros pueden ser de entrada o de salida.

Que un parámetro sea de entrada significa que el valor de la variable que se pasa
como argumento no cambiará aunque dentro del subprograma se modifique. Esto se debe a
que en un sector de la memoria se reserva un espacio equivalente al del argumento y es donde
se copian los mismos valores. Entonces el subprograma opera sobre el nuevo espacio de
memoria sin modificar el del argumento. A estos parámetros se los llama parámetros por
valor.

Es útil usar este tipo de parámetros si, por ejemplo, es necesario “cuidar” el contenido
de la variable que pasa como argumento.

Es posible que sea necesario, para una entidad invocadora, conocer las modificaciones
que se produzcan dentro del subprograma. Lo que se hace en esta situación es darle al
subprograma como dato la dirección de memoria de la variable que se pasa como argumento.
Se dice que este parámetro es parámetro por referencia, lo que indica que el subprograma
operará directamente sobre la variable que se pase como argumento. Si se modifica el valor
del parámetro dentro del subprograma se está modificando el argumento. En Pascal, para
obtener un parámetro por referencia se antepone la palabra reservada VAR a la declaración de
éste:

PROCEDURE identificador (VAR parámetroPorReferencia: tipoX; ....);

Si el procedimiento no tiene parámetros, es decir, no requiere datos a procesar y no

devuelve resultados, tanto en la invocación como en la declaración se escribe ‘;’ después del
identificador.

Edición Preliminar (bajo revisión) Página 12 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

El programa con procedimientos

C
'Ingrese la fecha (AAAAMMDD) :'

fecha

IngresarCodigoEmpleado
codigoEmpleado

bandera <-- FALSE

codigoEmpleado <> 0

bandera <-- TRUE

LeerDatos
cantServiciosVendidos, tipoEmpleado, anioIngreso

CalcularSueldoNeto
tipoEmpleado, sNeto, fecha, cantServiciosVendidos, anioIngreso

ImprimirEmpleado
codigoEmpleado, sNeto

sueldoMax <-- sNeto

codigoMax <-- codigoEmpleado

sueldoMin <-- sNeto

codigoMin <-- codigoEmpleado

IngresarCodigoEmpleado
codigoEmpleado

codigoEmpleado <> 0

LeerDatos
cantServiciosVendidos, tipoEmpleado, anioIngreso

CalcularSueldoNeto
tipoEmpleado, sNeto, fecha, cantServiciosVendidos

ImprimirEmpleado
codigoEmpleado, sNeto

CalcularMaximos
sueldoMax, codigoMax, sueldoMin, codigoMin, sNeto, codigoEmpleado

IngresarCodigoEmpleado
codigoEmpleado

bandera

ImprimirMaximos
codigoMax, sueldoMax, codigoMin, sueldoMin

F
Edición Preliminar (bajo revisión) Página 13 de 25
 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

Los procedimientos

IngresarCodigoEmpleado:

IngresarCodigoEmpleado
VAR codigoEmpleado: word

'Ingrese código de empleado: '

codigoEmpleado

R
E/S Identificador Descripción Tipo Bytes
E/S CodigoEmpl word 2

Observaciones:
-Este procedimiento imprime un literal por pantalla y obtiene el código de empleado
-El código de empleado es un parámetro por referencia pues es de salida.

LeerDatos:

LeerDatos
VAR cantServVend:word; VAR tipoEmpl:char; VAR anioIng:word

'Ingrese tipo de empleado: '

tipoEmpl

'Ingrese la cantidad de servicios vendidos: '

cantServVend

'Ingrese el año de ingreso: '

anioIng

E/S Identificador Descripción Tipo Bytes

E/S tipoEmp char 1
E/S cantServVend word 2
E/S anio word 2

Observaciones:
-Obtiene todos los datos que corresponden a cada empleado (salvo el código de
empleado).
-Todos sus parámetros son por referencia.

Edición Preliminar (bajo revisión) Página 14 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

SumarPorc:

SumarPorc
VAR sumaP: real; x, y: real

sumaP <-- x + x * y / 100

R
E/S Identificador Descripción Tipo Bytes
E/S sumaP Contiene la suma del valor más un porcentaje del mismo Real 6
E x Contiene el valor a sumarle un porcentaje Real 6
E y Porcentaje a sumarle a X Real 6

Observaciones:
-Como lo que interesa saber es el resultado de la suma de un valor inicial más un
porcentaje de ese valor, debe haber un parámetro que devuelva el resultado (sumap).
-Este procedimiento debe declararse antes de ser usado en CalcularSueldoNeto.

CalcularSueldoNeto:

CalcularSueldoNeto
tipoEmpleado: char; VAR sNeto:real; fecha:longint; cantServiciosVendidos:word; anioIngreso:longint

tipoEmpleado = 'F'

sueldo <-- SUELDO1 sueldo <-- SUELDO2

sBasico <-- sueldo + cantServiciosVendidos * COMISION

antiguedad <-- fecha DIV 1000 - anioIngreso

antiguedad
0 1, 2, 3 4, 5, 6 ELSE

sumarPorc sumarPorc sumarPorc sumarPorc

sBruto, sBruto, sBruto, sBruto,

sBasico, sBasico, sBasico, sBasico,
PLUS1 PLUS2 PLUS3 PLUS4

sumarPorc
sNeto, sBruto, APORT

Edición Preliminar (bajo revisión) Página 15 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

E/S Identificador Descripción Tipo Bytes

E fecha longint 4
antiguedad Contiene la antigüedad byte 1
E tipoEmpl char 1
E cantServiciosVendidos word 2
E anioIngreso word 2
sueldo Contiene el sueldo fijo (550 y 220) real 6
sBasico Sueldo fijo más comisiones real 6
sBruto Sueldo Basico más plus real 6

Observaciones:
-Para calcular el sueldo neto el único parámetro de salida es SNeto.
-Sueldo, SBasico, SBruto y F son variables locales.
-SUELDO1, SUELDO2, PLUS1, PLUS2, PLUS3, PLUS4, COMISION, APORTE, son
constantes. Las constantes son globales.

CalcularMaximos:

CalcularMaximos
VAR sMax:real; VAR codMax:word; VAR sMin:real; VAR codMin:word; sNeto:real; codEmpl:word

sNeto > sMax

sNeto < sMin

sMax <-- sNeto
sMin <-- sNeto
codMax <-- codEmpl
codMin <-- codEmpl

E/S Identificador Descripción Tipo Bytes

E CodEmpl word 4
E SNeto real 6
S Smax real 6
S Smin real 6
S CodMax word 4
S CodMin word 4

Observaciones:
-Devuelve cuatro valores de salida: SMin, SMax, CodMin, CodMax, que son los sueldos
Máximo y Mínimo y a quién corresponden (CodMax y CodMin).

Edición Preliminar (bajo revisión) Página 16 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

ImprimirEmpleado:

ImprimirEmpleado
codigoEmpleado:word, sNeto:real

'Empleado: ', codigoEmpleado

Sueldo neto: ', sNeto

E/S Identificador Descripción Tipo Bytes

E/S SNeto real 6
E/S CodigoEmpl word 2

Observaciones:
-Imprime el sueldo y el código del empleado que se está procesando.
-Todos sus parámetros son de entrada.

ImprimirMaximos:

ImprimirMaximos
codMax:word; sMax:real; codMin:word; sMin:real

codMin, 'posee el sueldo mínimo y es de ', sMin

codMax, 'posee el sueldo máximo y es de ', sMax

E/S Identificador Descripción Tipo Bytes

S sMin real 6
S CodMax word 4
S CodMin word 4
S sMax real 6

Observaciones:
-Imprime el sueldo máximo y el sueldo mínimo y a quién corresponden.

Código Fuente

Nota:
-Se supone que los datos son ingresados correctamente.
-En rojo aparecen las constantes, en negro las palabras reservadas de Pascal y en
azul los identificadores de los procedimientos definidos por el usuario.
-El ejercicio pudo haber sido resuelto utilizando menos variables, se hizo así con fines
pedagógicos y de legibilidad.

Edición Preliminar (bajo revisión) Página 17 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

-El ejercicio pudo haber sido resuelto utilizando menos repetición de código. Se hizo de
esta manera para mantener la lógica del programa en primer lugar y para resaltar el uso de
procedimientos y funciones en segundo lugar.

PROGRAM EjDeProcedimientos;

USES crt;

CONST
PLUS1 = 2;{Plus para empleados con 0 años de
antigüedad}
PLUS2 = 8;{Plus para empleados de 1 a 3 años de
antigüedad}
PLUS3 =10;{Plus para empleados de 4 a 6 años de
antigüedad}
PLUS4 =12;{Plus para empleados con más de 6 años de
antigüedad}
SUELDO1 = 550;{Sueldo fijo de empleados de tiempo
completo}
SUELDO2 = 220;{Sueldo fijo de empleados de medio
tiempo}
COMISION = 1.5;{Comisión por servicio vendido}
APORTE = -11;{Descuento por aportes}

VAR
sueldoNeto, sueldoMin, sueldoMax: real;
i, codigoEmpleado, CantServiciosVendidos,
anioIngreso, codigoMin, codigoMax: word;
fecha: longint;
tipoEmpleado: char;
antiguedad: byte;
bandera: boolean;

PROCEDURE IngresarCodigoEmpleado (VAR CodigoEmpleado: word);

BEGIN {Todo procedimiento Pascal comienza con begin}
write ('Ingrese el código de empleado: ');
readln (codigoEmpleado);
END; {Todo procedimiento Pascal termina con end;}

PROCEDURE LeerDatos (VAR cantServVend: word; VAR tipoEmpl: char; VAR

anioIng: word);
BEGIN
write ('Ingrese la cantidad de servicios vendidos: ');
readln (cantServVend);
write ('Ingrese el tipo de empleado(f:fulltime,p:parttime): ');
readln (tipoEmpl);
write('Ingrese el año de ingreso del empleado:’);
readln (anioIng);
END;

PROCEDURE SumarPorc (VAR sumaP:real; x: real; y: real);

BEGIN
SumaP := x + (x * y) / 100;
END; {Note la devolución de un único valor y además
representativo del procedimiento}

Edición Preliminar (bajo revisión) Página 18 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

PROCEDURE CalcularSueldoNeto (tipoEmpleado: char; VAR sNeto: real;

fecha: longint;
CantServiciosVendidos: word;
anioIngreso: word);

VAR
sBruto, sBasico, sueldo: real;
antiguedad: byte;

BEGIN
TipoEmpl := UpCase(TipoEmpl);{Es una función
predefinida. Si el argumento
que se
le pasa a Upcase es una letra
minúscula la pasa a
mayúscula}
IF TipoEmpl = 'F' THEN
sueldo := SUELDO1
ELSE
sueldo := SUELDO2;

sBasico := sueldo + cantServiciosVendidos * COMISION;

antiguedad := Fecha DIV 10000 - anioIngreso;

CASE antiguedad OF
0: SumarPorc (sBruto, sBasico, PLUS1);
1,2,3: SumarPorc (sBruto, sBasico, PLUS2);
4,5,6: SumarPorc (sBruto, sBasico, PLUS3)
ELSE
SumarPorc (sBruto, sBasico, PLUS4)
END;
SumarPorc (sNeto, SBruto, APORTE);
END; {Note la devolución de un único valor y además
representativo del procedimiento}

PROCEDURE CalcularMaximos (VAR sMax: real; VAR CodMax: word; VAR SMin:
real; VAR CodMin: word; sNeto: real;
codigoEmpl: word);

BEGIN
IF (sNeto > sMax) THEN
BEGIN
sMax := sNeto;
codMax := codigoEmpl;
END
ELSE
IF (sNeto < sMin) THEN
BEIGN
sMin := sNeto;
codMin := codigoEmpl;
END;
END;

PROCEDURE ImprimirEmpleado (codigoEmpl:word; sNeto:real);

BEGIN
writeln ('Empleado: ', codigoEmpl);
writeln ('Sueldo neto: ', sNeto:6:2);
END;

Edición Preliminar (bajo revisión) Página 19 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

PROCEDURE ImprimirMaximos (codMax: word; sMax: real; codMin: word;

sMin: real);
BEGIN
writeln (codMin,' posee el sueldo minimo y es de ', sMin:6:2);
writeln (codMax,' posee el sueldo maximo y es de ', sMax:6:2);
END;

BEGIN
clrscr; {Limpia la pantalla y pone el cursor en (X,Y) = (1,1)}
write ('Ingrese la fecha de hoy (AAAAMMDD): ');
readln (fecha);
IngresarCodigoEmpleado (codigoEmpleado);
bandera := false;
IF (codigoEmpleado <> 0) THEN
BEGIN
bandera := true;
LeerDatos (codigoEmpleado, cantServiciosVendidos,
tipoEmpleado, anioIngreso);
CalcularSueldoNeto (tipoEmpleado, sNeto, fecha,
cantServiciosVendidos, anioIngreso);
ImprimirEmpleado (codigoEmpleado, sNeto);
sueldoMax := sNeto;
codigoMax := codigoEmpleado;
sueldoMin := sNeto;
codigoMin := codigoEmpleado; {Estas asignaciones se
podrían hacer dentro de
un procedimiento}
IngresarCodigoEmpleado (codigoEmpleado);
END;
WHILE (CodigoEmpl <> 0) DO

BEGIN
LeerDatos (codigoEmpleado, cantServiciosVendidos,
tipoEmpleado, anioIngreso);
CalcularSueldoNeto (tipoEmpleado, sNeto, fecha,
cantServiciosVendidos, anioIngreso);
ImprimirEmpleado (codigoEmpleado, sNeto);
CalcularMaximos (sNeto, sueldoMax, codigoMax,
CodigoEmpleado, sueldoMin,
codigoMin);
IngresarCodigoEmpleado (codigoEmpleado);
END;

IF Bandera THEN {Bandera es una variable booleana que

indica si se procesaron datos o no: tengo
datos para imprimir, no tengo datos para
imprimir}
ImprimirMaximos (codigoMax, sueldoMax, codigoMin,
sueldoMin)
ELSE
writeln (‘No se procesaron datos’);
writeln ('Presione <enter> para salir');
readln; {Queda en espera para la lectura de un
enter. Este es un buen ejemplo de un procedimiento
que se invoca sin ningún parámetro. read, readln,
write y writeln son ejemplos de procedimientos con
cantidad de parámetros variable}

END.

Edición Preliminar (bajo revisión) Página 20 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

Como podemos observar, el procedimiento para calcular sueldo neto devuelve un único
valor (sNeto) al programa principal. Además, este valor es representativo del subprograma.
Notamos que sucede lo mismo con el procedimiento SumarPorc.

Funciones

Es posible que el usuario pueda declarar sus propias funciones de igual modo que
declara sus procedimientos.

Una función es un subprograma que devuelve un único resultado al programa o

subprograma invocante. La sintaxis de una función es muy similar a la de un procedimiento.

FUNCTION Identificador (parámetros): tipo;

CONST
...
TYPE
...
PROCEDURE ...
FUNCTION ...

VAR

BEGIN
...
{Desarrollo de la función}
...
END;

Observaciones:
-Todo cuerpo de una función comienza con BEGIN y termina con END;
-La estructura de una función es igual a la de un programa Pascal
-Tipo corresponde al tipo de dato que devuelve la función en su nombre.

Se invoca una función haciendo referencia a ella mediante su identificador. La llamada

se realiza en una expresión, o como argumento de otro subprograma (con ciertas
restricciones).

SumaPorc
(x, y: real) :real

SumaPorc <-- x + x * y / 100

R
Observaciones:
- El resultado se asigna directamente al identificador de la función.
Nota: También se utiliza un encabezamiento del siguiente tipo, para indicar lo mismo:

SumaPorc
x, y: real
:real

Edición Preliminar (bajo revisión) Página 21 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

El procedimiento CalcularSueldoNeto modificado como función SNeto:

SNeto
(tipoEmpleado: char; VAR sNeto:real; fecha:longint; cantServiciosVendidos:word; anioIngreso:longint) :real

tipoEmpleado = 'F'

sueldo <-- SUELDO1 sueldo <-- SUELDO2

sBasico <-- sueldo + cantServiciosVendidos * COMISION

antiguedad <-- fecha DIV 1000 - anioIngreso

antiguedad
0 1, 2, 3 4, 5, 6 ELSE

sBruto <-- sBruto <-- sBruto <-- sBruto <--

sumarPorc(sBasico, sumarPorc(sBasico, sumarPorc(sBasico, sumarPorc(sBasico,
PLUS1) PLUS2) PLUS3) PLUS4)

SNeto <-- sumarPorc(sBruto, APORTE)

Observaciones:
-El resultado del subprograma es devuelto en el identificador.

Su codificación sería:

FUNCTION SumarPorc (x: real; y: real): real;

BEGIN
SumarPorc := x + (x * y) / 100;
END;

FUNCTION Sneto (tipoEmpleado: char; fecha: longint;

CantServiciosVendidos: word;
anioIngreso: word): real;

VAR
sBruto, sBasico, sueldo: real;
antiguedad: byte;

BEGIN
TipoEmpl := UpCase(TipoEmpl);
IF TipoEmpl = 'F' THEN
sueldo := SUELDO1
ELSE
sueldo := SUELDO2;

Edición Preliminar (bajo revisión) Página 22 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

sBasico := sueldo + cantServiciosVendidos * COMISION;

antiguedad := Fecha DIV 10000 - anioIngreso;

CASE antiguedad OF
0: sbruto:= SumarPorc(sBasico, PLUS1);
1,2,3: sBruto:= SumarPorc(sBasico, PLUS2);
4,5,6: sBruto:= SumarPorc(sBasico, PLUS3)
ELSE
sBruto:= SumarPorc(sBasico, PLUS4);
END;
SNeto := SumarPorc (sBruto, APORTE);
END;

La invocación en el programa principal:

BEGIN
clrscr; {Limpia la pantalla y pone el cursor en (X,Y) = (1,1)}
write ('Ingrese la fecha de hoy (AAAAMMDD): ');
readln (fecha);
IngresarCodigoEmpleado (codigoEmpleado);
Bandera := false;
IF (codigoEmpleado <> 0) THEN
BEGIN
bandera := true;
LeerDatos (codigoEmpleado, cServiciosVendidos,
tipoEmpleado, anioIngreso);
sN := Sneto (tipoEmpleado, fecha,
cServiciosVendidos,
anioIngreso);{Habría
que declarar una nueva
variable sn, no puede haber
una variable con el mismo
nombre de una función o de un
procedimiento}
ImprimirEmpleado (codigoEmpleado, sNeto);
SMax := sN;
CodMax := codigoEmpl;
SMin := sN;
CodMin := CodigoEmpl;
IngresarCodigoEmpleado (codigoEmpleado);
END;
WHILE (codigoEmpleado <> 0) DO

BEGIN
LeerDatos (codigoEmpleado, cServiciosVendidos,
tipoEmpleado, anioIngreso);
sN := Sneto (tipoEmpleado, fecha,
cServiciosVendidos, anioIngreso);
ImprimirEmpleado (codigoEmpleado, sNeto);
CalcularMaximos (sN, sueldoMax, CodigoMax,
codigoEmpleado, sueldoMin,
codigoMin);
IngresaCodigoEmpleado (codigoEmpleado);
END;

IF Bandera THEN
ImprimirMaximos (codigoMax, sueldoMax, codigoMin,
sueldoMin);

writeln ('Presione <enter> para salir');

Edición Preliminar (bajo revisión) Página 23 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

readln;

END.

En lugar de guardar en Sn el valor del sueldo neto, se podría usar a la función como
argumento de los procedimientos que requieren el sueldo neto. Esto implicaría invocar la
función muchas veces, lo que significaría hacer muchas veces el mismo cálculo.

Parámetros de tipos especiales

Tipos enumerados de datos

Ejemplo 1:

PROGRAM TipoEnumeradoEnCicloExacto;
. . . ;
PROCEDURE ProcesarDatos(PMes:Meses);
. . . ;
TYPE
Meses = (Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio,
Agosto, Setiembre,
Octubre, Noviembre, Diciembre);
VAR
Mes: Meses;
BEGIN
. . . ;
FOR Mes := Marzo TO Diciembre DO
ProcesarDatos(Mes);
. . . ;

Ejemplo 2:

PROGRAM AnidamientoDeCiclos;
. . . ;
TYPE
Vocales = (a, e, i, o, u);
Texto = STRING[30];
. . . ;
PROCEDURE ImprimirVocal(Pvocal:Vocales);
BEGIN
CASE PVocal OF
a: WRITELN(‘a’);
e: WRITELN(‘e’);
i: WRITELN(‘i’);
o: WRITELN(‘o’);
u: WRITELN(‘u’)
END
END;
. . . ;
FUNCTION CoincidenPrimeraLetra(PPalabra: Texto; Pvocal: Vocal):
BOOLEAN;
VAR
Aux: CHAR;
BEGIN
CASE Pvocal OF
a: Aux := 'a';
e: Aux := 'e';

Edición Preliminar (bajo revisión) Página 24 de 25

 Universidad Tecnológica Nacional Algoritmos y Estructuras de Datos
Facultad Regional Buenos Aires Proyecto CoViE – Comunidad Virtual Educativa
Ingeniería en Sistemas de Información Subprogramas

i: Aux := 'i';
o: Aux := 'o';
u: Aux := 'u'
END;
CoincidenPrimeraLetra := Aux = PPalabra[1]
END;
VAR
Vocal: Vocales;
Palabra: Texto;
BEGIN
. . . ;
FOR Vocal := a TO u DO
BEGIN
WRITELN(‘Ingrese palabras que comiencen con ‘,
ImprimirVocal(Vocal));
READLN(Palabra);
WHILE CoincidenPrimeraLetra(Palabra, Vocal) DO
BEGIN
WRITELN(‘Ingrese palabras que comiencen con ‘,
ImprimirVocal(Vocal));
READLN(Palabra)
END;
WRITE(‘ERROR, entonces ahora . . .);
END;
. . . ;

Otros tipos de datos definidos por el programador

Antes de declarar un parámetro de tipo array, file, o puntero se debe definir el

correspondiente tipo de dato en la sección TYPE. Esto se debe a que si aparece en la lista de
parámetros una declaración del tipo, por ejemplo, var archivo: file of byte, se tendría un error de
compilación. Del mismo modo con vector: ARRAY [1.. 20] OF byte o ptr:^byte.

PROCEDURE EjemploDeLoQueNoSeHace (cadena: STRING[5]);

Para evitar este error se debe definir un tipo STRING[5] y utilizar ese tipo para declarar
el parámetro cadena.

TYPE
tCad5 = STRING[5];
...
PROCEDURE EjemploDeLoQueSiSeHace (cadena: tCad5);
...
VAR
cad: tCad5;
BEGIN
...
EjemploDeLoQueSiSeHace (cad);
...
END.

Observaciones:
-cad debe ser estrictamente de tipo tCad5, pues tCad5 es un string[5] pero no es el
mismo tipo. Si no es el mismo tipo, entonces, como ya se ha mencionado, es un error pasar
como argumento de un subprograma a una variable de distinto tipo que el parámetro
declarado.

Edición Preliminar (bajo revisión) Página 25 de 25