Programación Modular
Programación 1
Ing. Evelin Ramos Orellana
¿Qué es programación modular?
La programación modular es un paradigma de programación que
consiste en dividir un programa en módulos o subprogramas con el fin
de hacerlo más legible y manejable.
Se presenta históricamente como una evolución de la programación
estructurada para solucionar problemas de programación más grandes
y complejos de lo que esta puede resolver.
Al aplicar la programación modular, un problema complejo debe ser
dividido en varios subproblemas más simples, y estos a su vez en otros
subproblemas más simples aún. Esto debe hacerse hasta obtener
subproblemas lo suficientemente simples como para poder ser resueltos
fácilmente con algún lenguaje de programación. Esta técnica se llama
refinamiento sucesivo, divide y vencerás o análisis descendente (Top-
Down).
¿Qué es un Módulo?
Un 'módulo' es cada una de las partes de un programa que resuelve uno
de los subproblemas en que se divide el problema complejo original. Cada
uno de estos módulos tiene una tarea bien definida y algunos necesitan
de otros para poder operar. En caso de que un módulo necesite de otro,
puede comunicarse con este mediante una interfaz de comunicación que
también debe estar bien definida.
Si bien un módulo puede entenderse como una parte de un programa en
cualquiera de sus formas y variados contextos, en la práctica se los suele
tomar como sinónimos de procedimientos y funciones. Pero no necesaria
ni estrictamente un módulo es una función o un procedimiento, ya que el
mismo puede contener muchos de ellos. No debe confundirse el término
"módulo" (en el sentido de programación modular) con términos como
"función" o "procedimiento", propios del lenguaje que lo soporte.
Programa
suma
leer proceso imprimir principal
Variables
Cuando se consideran varios módulos de software y no un
solo programa principal, se pueden declarar variables
tanto en el contexto global del algoritmo, como de
manera local en cada módulo a lo que se le conoce
como alcance de las variables, en otras palabras esto
permite identificar la zona del programa donde una
variable es accesible “conocida”. Desde este punto de
vista, las variables pueden ser de dos tipos: locales o
globales.
Variables globales
Son las que son accesibles desde cualquier punto del programa y se
pueden usar desde cualquier módulo o subprograma, esto lleva a
considerar que la variable puede usarse en cualquier parte del programa
y su valor se puede alterar incontroladamente, y si posteriormente es
necesario usar la variable en otra parte del programa con su valor original,
se tendrá un error. El punto donde se da el error es fácil de localizar, pero
no lo es tanto el origen del mismo. Este tipo de efectos colaterales produce
errores cuyo origen es difícil de trazar y localizar: La programación modular
sugiere que se evite el uso de variables globales
Variables locales
Las variables locales sólo existen en un ámbito determinado del programa,
por ejemplo en un subprograma o en un bloque de sentencias. Solo
pueden ser utilizadas en el módulo donde fueron definidas.
Entonces si son analizados los conceptos de variables globales y locales, es
posible resumir que cuando se usan variables locales, éstas son
independientes de las globales y de las de otros módulos.
Subrutina y subprograma
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
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
Paso de parámetros a una función
Los parámetros son variables locales a los que se les asigna un
valor antes de comenzar la ejecución del cuerpo de una
función. Su ámbito de validez, por tanto, es el propio cuerpo de
la función. El mecanismo de paso de parámetros a las funciones
es fundamental para comprender el comportamiento de los
programas en C.
Considera el siguiente programa:
Los parámetros a y b declarados en la línea 1 son
válidos únicamente en la expresión de la línea 3. Las
variables x, y y z, por su lado, son válidas en el cuerpo
de la función main (líneas 7 a 11).
El ámbito de las variables x, y y z (ámbito llamador), y el
de las variables a y b (ámbito llamado) son totalmente
diferentes. El ámbito llamador desaparece
temporalmente cuando se invoca la función desde la
lińea 11. Durante esa ejecución, el ámbito llamado es
el visible. Al terminar la función, el ámbito llamado
desaparece y se recupera el ámbito llamador.
La comunicación entre estos dos ámbitos se realiza en
la línea 11. Antes de comenzar la ejecución de la
función, los valores de las variables del ámbito llamador
son copiadas sobre las variables del ámbito llamado.
Cuando termina la ejecución de la función, la
expresión de la llamada en la línea 11 se reemplaza por
el valor devuelto.
El paso de parámetros y la devolución de resultado en las funciones C se
realiza por valor, es decir, copiando los valores entre los dos ámbitos .
Las variables locales de la función (incluidos los parámetros) desaparecen al
término de la función, por lo que cualquier valor que se quiera guardar, debe
ser devuelto como resultado.
Tipos de parámetros
Los tipos de parámetros a utilizar van a depender siempre
de la necesidad que se le presente al programador. De
todos modos hay dos necesidades básicas que
generalmente están vigentes:
Poder obtener el contenido de una variable.
Poder modificar el contenido de una variable.
Parámetros por valor
Cuando surge la necesidad de obtener el valor o contenido de una
variable original o local a una función, en otra función, se utiliza
parámetros por valor. En este caso se produce una copia de la variable
original hacia el argumento formal de la función receptora. Dicha
variable tendrá como ámbito la función receptora y al culminar esta
liberará el espacio de memoria que ocupa.
void imprime_cantidad(int can){
printf(“%d\n”,can);
}
void alguna_funcion(void){
int cantidad;
:
imprime_cantidad(cantidad);
:
}
Parámetros por valor
El valor de una variable original puede pasar de una función a otra y a
su vez a otras funciones, sin inconvenientes. De pronto en nuestro
desarrollo, nos podemos encontrar con una hoja de ruta de valores de
variables que pasan por funciones. Si usamos parámetros por valor,
nunca podremos modificar los valores de las variables originales ya
que se producen copias de las mismas hacia las variables de la
función llamada y su ámbito es local. Al utilizar parámetros por valor,
éstos pueden ser constantes como por ejemplo:
#include <stdio.h>
void imprime_datos(char nombre[], int edad){
printf("Nombre :%s , edad: %d\n",nombre, edad);
}
int main(void){
char alias[35] = {"Pepe"};
imprime_datos(alias,23);
}
Parámetros por referencia
La referencia indica trabajar sobre la dirección de memoria que
ocupa el parámetro o variable original.
void ingresar_cantidad(int &can){
cin>>can;
}
void alguna_funcion(void){
int cantidad;
:
ingresar_cantidad(cantidad);
:
}
Parámetros por referencia
#include <iostream.h>
Como se observa en este ejemplo, el argumento de la
función receptora, presenta el operador unario &
void icrementa_sin_exito(int b) precediendo al nombre de la variable. Esto indica que
{ b++;} // no afecta a la variable original a
se tome la dirección del parámetro hacia el
argumento, produciendo un espejo o alias de la
void incrementa_con_exito(const int &b) variable original cantidad. Lo cual significará, que
{ b++;} // Error de compilación
toda alteración producida sobre el argumento can,
afectará a la variable original o parámetro cantidad.
void main(void){ Siempre que surja la necesidad de afectar a las
int a = 4; variables originales debemos usar parámetros por
referencia. Algunos casos serían: cargar un dato o
cout<<a<<"\n"; recalcular un dato.
incrementa_sin_exito(a); Ya que las funciones devuelven solo un valor, es
cout<<a<<"\n"; habitual usar varios parámetros por referencia cuando
necesitamos que una función provoque varios
incrementa_con_exito(a); resultados y no solo uno.
cout<<a<<"\n"; Si al argumento por referencia lo precedemos de la
} palabra const, dicha variable no podrá ser alterada
en el ámbito de la función receptora, por lo tanto
nunca afectará a la variable original.
Si extraemos la palabra reservada const de argumento b en la
función incrementa_con_exito(), no habría error de compilación y la
variable original a se vería afectada al incrementarse en uno por el b++.
Parámetros por referencia puntero
void carga(int &b){ // sin & funciona igual por que?
for (int i = 0;i < 5;i++)
La definición de los argumentos char s[]; cin>>b[i];
y char *s; son completamente }
equivalentes cuando se pasa un nombre Si escribimos
de un arreglo de caracteres a una void carga(int * b){
función. Ya que al pasar un arreglo como for (int i = 0;i < 5;i++)
parámetro, lo que en realidad se esta cin>>b[i];
pasando es la dirección del comienzo }
del mismo.
o bien
Recordemos la función carga() de void carga(int * b){
nuestro ejemplo de un arreglo de for (int i = 0;i < 5;i++)
números enteros. cin>>*b++;
}
En definitiva la variable original de tipo arreglo de enteros se verá modificada al
producirse la carga de elementos, manipulando el arreglo a partir de subíndices o
bien un puntero a enteros.
Parámetros por referencia puntero
También podríamos haber escrito la función carga del siguiente modo:
void carga(int * b){
for (int i = 0;*b == '\0';b++){
i++;
cin>>*b;
}
}
Siempre y cuando los elementos del arreglo estén inicializados en cero, ya que
de lo contrario tendríamos algunos inconvenientes.
Parámetros de tipo puntero o apuntadores siempre tomarán la dirección de la
variable original, por consecuencia la referencia a la misma.
Los parámetros por referencia puntero pueden tener el mismo cometido que
los por referencia, solo en el concepto que al modificar un argumento, se
afectará al parámetro. Pero no en su tratamiento, donde se trabaja siempre
sobre la base de la aritmética de punteros.
Completemos la idea, con un ejemplo
sencillo:
#include <iostream.h> #include <iostream.h>
void incrementa(int *b) {
void incrementa(int *b) {
(*b)++;
(*b)++;
}
}
void main(void){
void main(void){
int a = 4; int * ptero;
int a = 4; ptero = &a;
incrementa(&a); incrementa(ptero);
cout<<a<<"\n"; // imprime 5 cout<<a<<"\n"; // imprime 5
} }
que sería totalmente equivalente a escribir ya que el parámetro debe ser una variable de
tipo puntero o bien la dirección de una variable.
¿Que es un Prototipo?
Un prototipo es la forma de informar al compilador sobre el
valor de retorno de una función. Los prototipos también
permiten que el compilador identifique cualquier conversión
ilegal de tipo entre la definición y los parámetros de la
función. El prototipo también permite identificar cuando los
argumentos no corresponden con el número de argumentos
esperados.
La forma general de definición de un prototipo es:
tipo_devuelto nombre_funcion (tipo nombre_parametro1, tipo
nombre_parametro2, .. , tipo nombre_parametroN);
Ejemplo Programa que usa una función para sumar dos enteros en lenguaje C:
#include <stdio.h>
int sumar( int a, int b);/*Declaración del prototipo de la función sumar*/
int main()
{
printf("%d",sumar(5,6));/*Llamada a la función sumar desde la función printf */
return EXIT_SUCCESS;
}
int sumar( int a, int b)
{
return(a+b);
}
En este ejemplo, se usa el siguiente prototipo para la función sumar:
int sumar( int a, int b);
Sobra decir que el prototipo de la función debe coincidir con la implementación
de la misma.
El protipo de una subrutina o función se define antes de la función main, de tal
forma que al momento de usar dicha subrutina el compilador la identifique.
