PDF de programación - TEMA 5: Subprogramas, programación modular

TEMA 5: Subprogramas, programación modular

TEMA 5: Subprogramas, programación modular

5.1.-Definición de módulo. Programación modular

La programación modular está basada en la técnica de diseño descendente, que como ya
vimos consiste en dividir el problema original en diversos subproblemas que se pueden
resolver por separado, para después recomponer los resultados y obtener la solución al
problema.

Ejemplo:

Notas
Alumnos

Introducir

Listar

Encontrar un
alumno

Introducir un
alumno

Escribir un
alumno

Escribir un
alumno

Ejemplo:

m
n

⎛
⎜⎜
⎝

⎞
=⎟⎟
⎠

m
!
−

nmn
(!

)!

Un subproblema se denomina módulo y es una parte del problema que se puede resolver
de manera independiente. Que un módulo sea independiente nos permite, por un lado,
concentrarnos en su resolución olvidándonos del resto del problema, y por otro lado,
permite reutilizar la solución obtenida para otra parte del programa u otro programa
distinto.

Cada módulo se codifica dentro del programa como un subprograma, es decir, una
sección de código independiente que realiza una tarea específica dentro del programa.

El concepto de subprograma es una evolución del antiguo concepto de subrutina,
presente en lenguajes como ensamblador, Basic o primeras versiones de Fortran.

Fernando Barber y Ricardo Ferrís

55

TEMA 5: Subprogramas, programación modular
Una subrutina es una sección de código separada del programa principal que puede ser
llamada en un momento dado (llamada a subrutina) y que una vez acabada su ejecución
vuelve al punto donde se realizó la llamada.

Un subprograma hace el papel de un programa. Puede tener una sección de
declaraciones (variables, constantes, etc…) y posee también unos datos de entrada y de
salida. Esto permite, como ya veremos, que el subprograma sea
totalmente
independiente del programa principal.

Programa

Subrutina

Programa Principal

Subprograma

(1)

Inicio

Llamada

(2)

Final

1

3

Parámetros
reales

Parámetros

formales

(1)

4

(2)

X

Y

Inicio

Z := X+Y

Final

Z

5.2 Definición de subprogramas: funciones

En un subprograma hay que distinguir dos aspectos fundamentales:

• La definición del subprograma: Es la especificación de los parámetros de entrada y

salida y las sentencias del subprograma.

• La llamada al subprograma: Es una sentencia que pasa el control del programa al
subprograma. Cuando el subprograma acaba su ejecución, el control vuelve a la
sentencia siguiente a la llamada.

Un subprograma puede necesitar o devolver datos. A estos datos se les denomina
parámetros. Los parámetros pueden ser de entrada o de salida.

Los parámetros que se incluyen en la definición del subprograma se denominan
parámetros formales. Los parámetros que se pasan al subprograma en la llamada se
denominan parámetros reales.

Fernando Barber y Ricardo Ferrís

56

5.2.1.-Definición de funciones en C++:

TEMA 5: Subprogramas, programación modular

En C++ los únicos tipos de subprogramas existentes son las funciones. Una función es
un subprograma que siempre tiene un parámetro de salida (Ej.: cos(x), pow(2,3) ). Una
función se define de la siguiente manera:

{

Tipo Nombre(lista de parámetros)
Declaraciones
Instrucciones
return Valor;
}

Cabecera de la función

Cuerpo de la función

Donde tipo es el tipo del dato de salida, nombre es un identificador que representa el
nombre de la función, lista de parámetros es una lista de parámetros separados por
comas, donde cada parámetro se declara como en una declaración de variables normal.

Mediante la instrucción return se indica el valor que devolverá la función al acabar su
ejecución.

Ejemplo:

int main()
{
float x, y;
x = triple(3) + 2;
→
y = triple(triple(2)); →
....
}
float triple(float x)
{
return (3 * x);
}

x = 9 + 2
y = triple(6) → y = 18

Cuando hacemos una llamada a una función, lo primero que se realiza es una asignación
de los parámetros reales a los parámetros formales y a continuación se ejecutan las
instrucciones de la función.

Si queremos una función que no devuelva ningún valor, se declara de tipo void.

Fernando Barber y Ricardo Ferrís

57

TEMA 5: Subprogramas, programación modular

Ejemplo:

void EscribeSuma(int a, int b)
{
cout << a + b;
return;
}

Una función, al igual que cualquier otro identificador, sólo se puede utilizar a partir del
momento en que lo declaramos. Para poder utilizar las funciones en cualquier punto del
programa, lo que se hace es declararlas al principio del programa.

La declaración de una función únicamente necesita la cabecera y se denomina
prototipo.

Ejemplo: Prototipo para la función triple

float triple(float x);

5.3.-Ámbito de identificadores

Ámbito de un identificador: Conjunto de sentencias donde puede utilizarse ese
identificador.

Reglas para el cálculo del ámbito de un identificador:

1. Un identificador declarado en un bloque es accesible únicamente desde ese bloque y
todos los bloques incluidos en él (se considera local a ese bloque). Un parámetro
formal se considera también una declaración local al bloque de la función.

2. Los identificadores declarados fuera de cualquier bloque se consideran globales y

pueden ser utilizados desde cualquier punto del fichero.

3. Cuando tenemos un bloque dentro de otro bloque y en ambos se declaran
identificadores con el mismo nombre, el del bloque interno "oculta" al del bloque
externo. (Ojo!! En C++ se admite la declaración de variables en cualquier bloque).

Fernando Barber y Ricardo Ferrís

58

TEMA 5: Subprogramas, programación modular

Ejemplo de ámbito

/**************************************************/
/* Programa ejemplo de ámbito */
/**************************************************/
#include <iostream.h>
int z; // Global
int Sumar(int x, int y);
int main()
{
int suma; // Local a main
z = 3;
suma = Sumar(2, 3);
cout << suma << endl << z << endl;
return 0;
}
int Sumar(int x, int y)
{
int z; // Local a Sumar.
// Oculta la z global
z = x + y;
return z;
}

En una función sólo se deben utilizar variables locales a la función o parámetros(que
también son variables locales). Las variables globales no se deben utilizar nunca.

La razón es porque de esta manera la función es independiente del programa principal.
La independencia permite que sea más fácil hacer cambios al programa, que la función
pueda ser reutilizada en otros programas y que sea más fácil trabajar en equipo.

Además, si no se siguen estas reglas se pueden producir efectos laterales.

Fernando Barber y Ricardo Ferrís

59

TEMA 5: Subprogramas, programación modular

Ejemplo:
int z;
int Sumar(int x, int y);
int main()
{
int suma;
z = 3;
suma = Sumar(2, 3);
cout << z;
}
int Sumar(int x, int y)
{
z = x + y;
return z;
}

-> 5
-> 5 (Efecto lateral)

En este ejemplo, la variable z ha cambiado "misteriosamente" de valor. Esto es lo que
se denomina efecto lateral, que una función modifique el valor de variables que no han
sido pasadas como parámetros.

Además, si cambiamos el nombre de la variable ‘z’, el procedimiento dejará de
funcionar.

5.4.-Parámetros de un subprograma

Existen dos posibilidades para pasar parámetros a un subprograma: por valor y por
referencia.

5.4.1.-Paso por valor

Se coge el valor del parámetro real y se asigna al parámetro formal. El parámetro formal
es, por tanto, una copia del parámetro real.

Se utiliza exclusivamente para parámetros de entrada.

Fernando Barber y Ricardo Ferrís

60

TEMA 5: Subprogramas, programación modular

Ejemplo:

Todos los ejemplos que hemos visto hasta ahora utilizan paso de parámetros
por valor.
void UnoMenos(int x)
{
x = x - 1;
cout << x;
return;
}
...
n = 4;
UnoMenos(n);
cout << n;
‘n’ no cambia su valor.

→ 3
→ 4

5.4.2.-Paso por referencia

El paso de parámetros por referencia une la variable del parámetro formal con la
variable del parámetro real y son tratadas como una sola variable. Sólo se pueden pasar
por referencia variables.

Se utiliza para parámetros de entrada/salida.

Se diferencia del paso por valor poniendo el símbolo &.

Ejemplo:

void UnoMenos(int & x)
{
x = x - 1;
cout << x;
return;
}
...
n = 4;
UnoMenos(n);
cout << n;

→ 3
→ 3

Fernando Barber y Ricardo Ferrís

61

TEMA 5: Subprogramas, programación modular

void intercambio(int & x, int & y)
{
int z;
z = x;
x = y;
y = z;
return;
}

Las funciones son las únicas que tienen un parámetro exclusivamente de salida, y el
paso de este parámetro es por valor.

5.4.3.-Gestión de la memoria

La memoria que utilizan las funciones se gestiona como una pila.

Cuando llamamos a un procedimiento, se reserva espacio para las variables locales
“apilando” las variables. Cuando se acaba el procedimiento, las variables son
“desapiladas” y por tanto dejan de existir.

En un lenguaje que sólo tenga gestión de memoria estática, realmente no existen
subprogramas ni variables locales, únicamente subrutinas y variables globales.

Ejemplo:

int n, s;
void calculo(int x, int & z);
void subcalculo(int xx);
int main()
{
n = 5; s = 3;
calculo(n, s);
...
}
void calculo(int x, int & z)
{
int cc;

Fernando Barber y Ricardo Ferrís

62

TEMA 5: Subprogramas, programación modular

...
cc = 6;
subcalculo(cc);
...
return;
}
void subcalculo(int xx);
{
int dd;
...
return;
}

Llamadas

N:= 5;
S:=3;
calculo(N,S);

...

cc:=6;
(*llamada 2*)
subcalculo(cc);

(*retorno llamada 2*)

(*retorno llamada 1*)

Z/S

X

XX

CC

Z/S

X

CC

Z/S

X

3

5

6

6

3

5

6

3

5

variables
locales

Parámetros
de
entrada

Parámetro
de
entrada

CC

??

Z/S

X

3

5

dd

??

XX

CC

Z/S

X

6

6

3

5

dd

??

XX

6

CC

??

3

X

5

Z

S

3

Leyenda