Procedimientos en Pseudocódigo

En pseudocódigo, la sintaxis que se puede utilizar (compatible con PSeInt) para escribir un procedimiento es muy similar a la que se usa para escribir un algoritmo:

// Cabecera

SubProceso <nombre_del_procedimiento>( [ <lista_de_parámetros_formales> ] )

   // Declaraciones

   // Cuerpo

   <bloque_de_instrucciones>

FinSubProceso

Por otra parte, para hacer una llamada a un procedimiento, se puede utilizar la sintaxis:

<nombre_del_procedimiento>( [ <lista_de_parámetros_actuales> ] )

Cuando se hace una llamada a un procedimiento, este se ejecuta y, al finalizar, devuelve el control del flujo al programa (o subprograma) llamante, el cual continuará su ejecución con la siguiente instrucción a la llamada.

EJEMPLO Se quiere diseñar el algoritmo de un programa que:

1º) Muestre un menú con 4 opciones:

• 1. Mostrar los números del 1 al 10 (ambos inclusive).
• 2. Mostrar la tabla de multiplicar del 8.
• 3. Mostrar las primeras diez potencias de 2.
• 4. Salir.

2º) Pida por teclado la opción deseada (dato carácter). Deberá ser introducida, hasta que, sea mayor o igual que '1' y menor o igual que '4'.

3º) Ejecute la opción del menú seleccionada.

4º) Repita los pasos 1º, 2º y 3º, hasta que, el usuario seleccione la opción 4 (Salir) del menú.

En pantalla se verá, por ejemplo:

La solución al problema planteado puede venir dada por un módulo principal (programa o algoritmo principal) y cuatro submódulos (subprogramas o subalgoritmos):

// Ejemplo: Menú de opciones

// Procedimiento que muestra las opciones del menú por pantalla
SubProceso  Menu_por_Pantalla()
   Escribir ""
   Escribir ">> MENÚ DE OPCIONES <<<"
   Escribir ""
   Escribir "1. Números del 1 al 10."
   Escribir "2. Tabla de multiplicar del 8."
   Escribir "3. Primeras diez potencias de 2."
   Escribir "4. Salir."
   Escribir ""
FinSubProceso

// Procedimiento que muestra los números del 1 al 10 por pantalla
SubProceso Numeros_del_1_al_10()
   Definir n Como Entero
   Para n <- 1 Hasta 10 Hacer
      Escribir Sin Saltar n, " "
   FinPara
   Escribir ""
FinSubProceso

// Procedimiento que muestra la tabla de multplicar del 8 por pantalla
SubProceso Tabla_de_Multiplicar_del_8()
   Definir i, resultado Como Entero
   Para i <- 1 Hasta 10 Hacer
      resultado <- i * 8
   Escribir "8 * ", i, " = ", resultado
   FinPara
FinSubProceso

// Procedimiento que muestra las diez primeras potencias de 2 por pantalla
SubProceso Primeras_Diez_Potencias_de_2()
   Definir i Como Entero
   Para i <- 1 Hasta 10 Hacer
      Escribir Sin Saltar 2 ^ i, " "
   FinPara
   Escribir ""
FinSubProceso

// Algoritmo principal
Algoritmo Menu_de_Opciones

   Definir opci Como Caracter

   Repetir

      Menu_por_Pantalla()

      // Filtramos la opción elegida por el usuario

      Repetir
         Escribir Sin Saltar "Introduzca opción (1-4): "
         Leer opci
      Hasta Que opci >= '1' & opci <= '4'

      // La opción solo puede ser '1', '2', '3' o '4'

      Escribir ""

      Segun opci Hacer

         '1': Numeros_del_1_al_10()

         '2': Tabla_de_Multiplicar_del_8()

         '3': Primeras_Diez_Potencias_de_2()

      FinSegun

   Hasta Que opci = '4'

FinAlgoritmo

Parámetros de un subalgoritmo

Los parámetros (también llamados argumentos) se emplean, opcionalmente, para transferir datos de un programa (o subprograma) llamante, a otro llamado, y viceversa (del llamado al llamante), o dicho de otro modo, en una llamada a un subprograma, el llamante y el llamado se pueden enviar datos entre sí, mediante parámetros. De manera que, en una llamada a un subprograma, los parámetros se usan para:

• Proporcionar uno o más datos de entrada al llamado.
• Devolver uno o más datos de salida al llamante.

Por tanto, los parámetros se pueden clasificar en:

• De entrada
• De salida
• Y también, de entrada y salida.

Como su propio nombre indica, un parámetro de entrada y salida se utiliza para proporcionar un dato de entrada al llamado y, también, para devolver un dato de salida al llamante.

EJEMPLO Se quiere diseñar el algoritmo de un programa que:

1º) Pida por teclado dos números (datos enteros).

2º) Calcule la multiplicación de los dos números introducidos por el usuario.

3º) Muestre por pantalla el resultado (dato entero).

En la pantalla se verá:

Sin usar subalgoritmos, la solución al problema puede ser la siguiente:

// Ejemplo: Multiplicación de dos números enteros

Algoritmo Multiplicacion_de_Dos_Numeros_Enteros

   Definir a, b, r Como Entero

   Escribir Sin Saltar "Introduzca el primer número: "
   Leer a
   Escribir Sin Saltar "Introduzca el segundo número: "
   Leer b

   r <- a * b

   Escribir "La multiplicación es: ", r

FinAlgoritmo

En este caso, vamos a considerar como un subproblema la realización de la multiplicación.

Parámetros formales

Los parámetros formales, también llamados ficticios, son variables locales que se pueden declarar en la cabecera de un procedimiento, en las cuales se almacenarán:

• Los datos de entrada que se le proporcionen al procedimiento en la llamada.
• Así como, los datos de salida que se devolverán al subprograma llamante.
• Y también, los datos de entrada y salida.

En un subprograma, las variables locales declaradas en la sección de declaraciones, se diferencian de las variables locales declaradas en la cabecera (parámetros), en que, estas últimas, se utilizan para transferir datos entre el llamante y el llamado, y las otras no.

Para escribir la <lista_de_parámetros_formales> de un subalgoritmo, se puede utilizar la sintaxis:

<variable_1> [ Por Valor | Por Referencia ],
<variable_2> [ Por Valor | Por Referencia ],
...
<variable_n> [ Por Valor | Por Referencia ]

Obsérvese que, de cada parámetro (variable) se puede indicar si es Por Valor o Por Referencia, y todos ellos se escriben separados por comas (,).

De modo que, suponiendo que al subalgoritmo (procedimiento) que da solución al subproblema planteado (realizar la multiplicación de dos números enteros) se le pasen –Por Valor– dos datos de entrada (los dos números introducidos por el usuario) en la llamada, y devuelva –Por Referencia– un dato de salida (el resultado de la multiplicación), el procedimiento que da solución a dicho subproblema, puede ser:

SubProceso Multiplicar(n1 Por Valor, n2 Por Valor, resultado Por Referencia)
   resultado <- n1 * n2
FinSubProceso

Los parámetros n1 y n2, son variables de entrada (Por Valor). Por tanto, cuando se realice una llamada al procedimiento Multiplicar, se tienen que proporcionar los datos que se almacenarán (recogerán) en dichos parámetros.

Por otra parte, cuando el procedimiento Multiplicar finalice, el parámetro resultado (Por Referencia) debe contener un dato que se devolverá al llamante. Dicho dato, se almacenará en una variable local declarada en el llamante, o en una global.

Parámetros actuales

Los parámetros de una <lista_de_parámetros_actuales>, que se pueden indicar al hacer una llamada a un procedimiento, deben ir separados por el carácter coma (,).

En una llamada a un subprograma, el número de parámetros actuales, también llamados reales, debe coincidir con el número de parámetros formales declarados en el subprograma, existiendo una correspondencia de tipos de datos entre ellos, es decir, el primer parámetro formal debe ser del mismo tipo de dato que el primer parámetro actual, y así con todos.

Los parámetros actuales que se correspondan con parámetros formales de entrada, pueden ser expresiones. De esta forma, el resultado de evaluar un parámetro actual (expresión), se proporciona como dato de entrada al llamado. Sin embargo, los parámetros actuales que se correspondan con parámetros formales de salida o de entrada y salida, solo pueden ser variables, ya que, un dato de salida devuelto por el llamante, se almacena en un parámetro actual, el cual, obviamente, solo puede ser una variable.

Así pues, usando el procedimiento Multiplicar, la solución algorítmica al problema planteado, puede ser la siguiente:

// Ejemplo: Multiplicación de dos números enteros

SubProceso Multiplicar(n1 Por Valor, n2 Por Valor, resultado Por Referencia)
   resultado <- n1 * n2
FinSubProceso

Algoritmo Multiplicacion_de_Dos_Numeros_Enteros

   Definir a, b, r Como Entero

   Escribir Sin Saltar "Introduzca el primer número: "
   Leer a
   Escribir Sin Saltar "Introduzca el segundo número: "
   Leer b

   Multiplicar(a, b, r)

   Escribir "La multiplicación es: ", r

FinAlgoritmo

Suponiendo, por ejemplo, que el usuario desee calcular la multiplicación de los números 26 y 3, cuando en el algoritmo se hace la llamada al procedimiento Multiplicar:

Multiplicar(a, b, r)

En los parámetros n1 y n2 del procedimiento, se almacenan (copian) los datos de entrada (26 y 3) proporcionados en la llamada.

26 y 3 son los resultados de evaluar las expresiones (variables en este caso) a y b, respectivamente.

Paso por valor

Cuando el valor (dato) de un parámetro actual (a por ejemplo), se transfiere (copia) a un parámetro formal de entrada (n1, en este caso), se dice que se está realizando un paso por valor.

El paso por valor implica la asignación:

<parámetro_formal_de_entrada> <- <parámetro_actual>

En solución planteada, se producen los pasos por valor siguientes:

n1 <- a
n2 <- b

Paso por referencia

Por otro lado, en el parámetro r (variable de salida) se almacena el valor (dato) 78, como consecuencia de la instrucción de asignación:

resultado <- n1 * n2

Puede parecer que, al igual que antes, cuando finalice el procedimiento Multiplicar, se efectuará la asignación:

r <- resultado

Pero, en realidad, resultado no es una variable que almacene un dato de tipo entero, ya que, un parámetro formal de salida, como es el caso de resultado, representa al espacio de memoria en el cual se almacena la dirección de memoria del parámetro actual correspondiente, r en este caso.

Por tanto, cuando al parámetro formal de salida (resultado) se le asigna un valor dentro del procedimiento Multiplicar, lo que se está haciendo realmente, es asignar dicho valor al parámetro actual correspondiente (r), es decir, resultado hace referencia a r y, por tanto, se dice entonces que se está realizando un paso por referencia.

Es importante comprender que, cuando se realiza un paso por valor, si se modifica el valor del parámetro formal en el subprograma llamado, haciendo por ejemplo:

n1 <- 18

Dicha modificación no afectaría al parámetro actual (a en este caso), que seguiría conteniendo el valor 26. Pero, si el paso fuese por referencia, entonces sí que afectaría.