Instituto Tecnológico de

Matamoros

Fundamentos de Programación
5. Modularidad

Instituto Tecnológico de Matamoros

enero – junio 2024
 FUNDAMENTOS DE PROGRAMACIÓN

Competencia Tema 5:
Conoce y aplica la modularidad en el desarrollo de programas para
la optimización de los mismos y reutilización de código.
 MODULARIDAD
Desarrollo del Tema
El quinto tema tiene como finalidad que el estudiante implemente
el diseño de bloques de códigos reutilizables, que optimizan la
funcionalidad y reducen la complejidad de los programas
desarrollados.
5.1 Declaración y Uso de Módulos
 Modularidad
• La modularidad se basa en la descomposición de un problema, es una
serie de subproblemas; dividiéndolo en módulos que resultan de
segmentar el problema en funciones lógicas que son perfectamente
diferenciadas.
• Esta división exige la presencia de un módulo denominado módulo de
base o principal a objeto de que controle y se relacione con los demás.
• Es una técnica de programación que todavía se utiliza tanto para la
construcción de algoritmos computacionales básicos, así como apoyo al
desarrollo de sistemas de gestión (en el diseño de diagramas
modulares).
• Modularizar significa que el algoritmo se fragmenta en partes llamadas
módulos. En realidad, es un método de diseño que tiende a dividir el
problema, de forma lógica, en partes perfectamente diferenciadas que
pueden ser analizadas, programadas y puestas a punto independiente.

• Módulo: Es aquél que está constituido por una o varias instrucciones

físicamente contiguas y lógicamente encadenadas, las cuales se
pueden referenciar mediante un nombre y pueden ser llamadas desde
diferentes puntos de un programa. Un módulo puede ser:
 Un programa.
 Una función.
 Una subrutina (o procedimiento).
Principios de los Diseños Modulares
• Soporte de lenguaje para unidades modulares.
• Pocas interfaces .
• Interfaces pequeñas (Acoplamiento débil).
• Interfaces explícitas.
• Ocultación de la información.

Parámetros

Subrutina o
función

Valor de
retorno
 Ventajas de Utilizar Módulos
• Un programa modular es fácil de mantener y modificar.
• Un programa modular es más fácil de escribir y depurar (ejecutar,
probar y poner a punto).
• Un programa modular es más fácil de controlar. El desglose de un
problema en módulos permite encomendar los módulos más
complejos a los programadores más experimentados y los más sencillos
a los programadores nóveles.
• Posibilita el uso repetitivo de las rutinas en el mismo o en diferentes
programas.
 Desventajas de Utilizar Módulos
• No se dispone de algoritmos formales de modularidad, por lo que a
veces los programadores no tienen claras las ideas de módulos.
• La programación modular requiere más memoria y tiempo de
ejecución.
Reglas para el uso de funciones:
• 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.
Origen de la Programación Modular
Está basada en la técnica de diseño
descendente (top down), que consiste
en dividir el problema principal en un
conjunto de subproblemas menores,
los cuales a su vez pueden ser
divididos aún más, y se continúa con
este proceso, es decir, el problema se
resuelve de arriba hacia abajo hasta
obtener subproblemas que puedan ser
manejados y sencillos de resolver para
obtener la solución al problema.
En programación a los procedimientos y funciones también
se les conoce por el nombre de:
• rutinas,
• subrutinas o
• subprogramas.
Un procedimiento es una parte del programa que realiza una acción
específica basada a menudo en una serie de parámetros o argumentos.
Se ejecuta simplemente con una sentencia que es igual a su
identificador seguido de los parámetros correspondientes, si los tiene,
entre paréntesis.

A diferencia de las funciones, no tiene sentido situarlos en una

expresión porque no devuelven un valor una vez que termina su
ejecución. lo que se declare localmente en (dentro de) un
procedimiento no se podrá utilizar en otra parte del programa fuera
del procedimiento, mientras que lo que se declare previamente a nivel
global en el programa sí se podrá utilizar en el procedimiento.
Una función es una parte del programa que puede manipular datos y
devolver un valor de un cierto tipo. Se ejecuta al hacer una llamada a
dicha función dentro de una expresión. La llamada a una función puede
incluirse en cualquier expresión en la que un dato del tipo que devuelve
la función tenga sentido.

Mientras que un procedimiento ejecuta un grupo de sentencias, una

función además devuelve un valor al punto donde se llamó. Una llamada
a una función puede aparecer como operando de alguna expresión. El
valor de la función se usa, por tanto, para calcular el valor total de la
expresión.
Las rutinas son bloques de instrucciones que realizan tareas
específicas. Se declaran una sola vez, pero pueden ser utilizadas,
mediante llamadas, todas las veces que se quiera en un programa.

Una rutina es independiente del resto del programa por lo que, en

principio, facilita el diseño, el seguimiento y la corrección de un
programa. Pueden además almacenarse independientemente en
colecciones llamadas librerías o unidades, lo cual permite que sean
utilizadas en cualquier programa. De hecho, existen funciones y
procedimientos que vienen ya construidos para el lenguaje de
programación.
Subproblema
Se le denomina módulo y es una parte del problema que se puede resolver
de manera independiente, lo cual 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.

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.
5.2 PASO DE PARÁMETROS
O ARGUMENTOS
 Parámetros y Argumentos
Son el medio a partir del cual podemos expandir el ámbito de variables
locales de funciones, hacia otras funciones y además quienes nos
permiten establecer comunicaciones entre funciones.
Un parámetro es una variable en una definición de método. Cuando se
llama a un método, los argumentos son los datos que se pasan a los
parámetros del método.

• Parámetro, es variable en la declaración de una función.

• Argumento, es el valor real de esta variable que se pasa a la función.
Por ejemplo, un procedimiento que calcule la suma de dos números
enteros necesitará dos parámetros, uno para cada número. En general, un
procedimiento puede ser definido con cualquier número de parámetros (o
ninguno). Si un procedimiento tiene parámetros, la parte de su definición
que los especifica es llamada lista de parámetros.
En tanto, los argumentos son más bien los valores actuales asignados a los
parámetros variables cuando la función es llamada.
Cuando se realiza una llamada a la función, los "valores" pasados se
denominan argumentos.
• En pocas palabras, la principal diferencia entre parámetro y argumento
es lo mismo que "identificador y valor“.
Se puede crear una función de tal forma que permita trabajar con uno o más
parámetros, un ejemplo muy básico es una función que calcula el impuesto sobre un
monto.
function calcula_impuesto(monto){
return monto * 0.13;
}
Como vemos en el código anterior declaramos la función con un parámetro llamado
monto y usa ese parámetro para calcular y devolver el valor del impuesto que
corresponde. Ahora cuando llamamos a esa función lo hacemos de esta forma:
impuesto = calcula_impuesto(100);
En el código anterior llamamos a la función calcula_impuesto con el argumento 100.
Le llamamos parámetros cuando los usamos para definir la función, y le llamamos
argumentos a los valores que se usan cuando usamos a la función.
Entonces en el caso anterior, monto será el parámetro y 100 es el argumento.
 void funcion_llamada(int x) //crea la función que recibe un argumento
{
:
}
void una_funcion(void)
{
int a,b; //variables de ámbito local
:
:
funcion_llamada(a); //llamada de la función con un parámetro
:
}

La expresión funcion_llamada(a); se denomina llamado a la función con un parámetro

a de tipo entero. Y la expresión void funcion_llamada(int x) se denomina cabecera de
la función con un argumento, en este caso x, también de tipo entero.
 Parámetros

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.
Muchas veces los procedimientos y funciones requieren que le
envíen una lista de valores llamados parámetros (argumentos), para
usarlos en la solución de la tarea encomendada.

Los parámetros son variables muchas veces de entrada (reciben

valores) y de salida (devuelven resultados) o ambos de
entrada/salida.

En C++ existen dos formas de pasar parámetros a una función:

• por valor (entrada)
• por referencia (salida).
 Parámetros por Valor (entrada)
Los valores que se envían a los parámetros son asignados como
una copia de los valores originales, desconectando el programa
principal con el subprograma, es decir si los valores de los
parámetros cambian dentro del subprograma no afecta al
programa principal.

La información se pasa a las funciones como un parámetro. Los

parámetros actúan como variables dentro de la función.
Los parámetros se especifican después del nombre de la función,
dentro de los paréntesis. Se puede agregar tantos parámetros
como se desee, simplemente se separan con una coma.

Sintaxis:

tipo nombredelafunción (parámetro1, parámetro2, parámetro3)

{
// cuerpo de la función
}
 Parámetros por Referencia (salida)
Se asignan las referencias de las variables (dirección de memoria de la variable) a los
parámetros, conectando el programa principal con el subprograma, es decir si los
valores de los parámetros cambian dentro del subprograma afecta a las variables
del programa principal. También puede pasar una referencia a la función.

Esto puede ser útil cuando se

necesita cambiar el valor de
los argumentos, por ejemplo:
5.3 IMPLEMENTACIÓN
 Funciones de C++
Una función es un bloque de código que sólo se ejecuta cuando se
llama.

Puede pasar datos, conocidos como parámetros, a una función.

Las funciones se utilizan para realizar ciertas acciones y son

importantes para reutilizar el código: defina el código una vez y úselo
muchas veces.
Una función básica C++ consta de dos
partes:
• Declaración: tipo de retorno, nombre de la función y
parámetros (si los hay).
• Definición: el cuerpo de la función (código a ejecutar).

void myFunction( ) //declaración

{
//el cuerpo de la función (definición)
}
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.
Funciones void
Bajo ciertas circunstancias se deseará escribir funciones que
no regresen valor alguno y para ello podemos declarar la
función como void.

La palabra reservada void es utilizada para declarar funciones

sin valor de retorno y también para indicar que una función
específica no requiere de parámetros.
Crear una Función

C++ proporciona algunas funciones predefinidas, como main( ),

que se utiliza para ejecutar código. Pero también puede crear
sus propias funciones para realizar ciertas acciones.

Para crear (a menudo denominado declarar) una función, se

especifica el nombre de la función, seguido de paréntesis ( ).
Sintaxis para la definición de una función en C++

Tipo Nombre(lista de parámetros) //Cabecera de la función

{
conjunto de Instrucciones //Cuerpo de la función
return valor;
}

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 (tipo var1, tipo var2,… tipo varn) donde
cada parámetro se declara como en una declaración de variables normal, y
valor es aquel dato que regresaremos y debe coincidir con el tipo declarado
al inicio.
 Sintaxis Ejemplo
tipo nombredelafunción( ) void myFunction( )
{ {
//cuerpo de la función //código a ejecutar
} }

Explicación:

• myFunction( ) es el nombre de la función.

• void significa que la función no tiene un valor de retorno.
• Dentro de la función (el cuerpo), agregamos código que
defina qué debe hacer la función.
 Estructura de la Función en C++

Tipo de retorno: Es el tipo de dato que devuelve la función.

Lista de parámetros: Es una lista de parámetros tipificados (con tipos) que utiliza el formato
siguiente: tipo1 parametro1, tipo2 parametro2,……..
Cuerpo de la función: Se encierra entre llaves ( { ) de apertura ( } ) y cierre. No hay punto y coma
después de la llave del cierre.
Declaración local: Las constantes, tipos de datos y variables declaradas dentro de la función son
locales a la misma.
Valor devuelto por la función: Mediante la palabra reservada return se puede devolver el valor
de la función.
Ejemplos de Funciones en C++

• int numMax (int x, int y)

• double intercambio (double x, double y)
• void desplegar (float x, float y)
 Llamada a una Función
• Las funciones, para poder ser ejecutadas, han de ser llamadas o
invocadas.
• Si la función requiere de parámetros éstos deberán indicarse
dentro de paréntesis.
• Para llamar a una función que no requiera de parámetros se deberá
indicar el nombre de la misma seguida de paréntesis vacíos.
• Normalmente la llamada a una función se realizará desde la función
principal main(), aunque también podrá ser desde otra función.
 Para Llamar a una Función

Las funciones declaradas (creadas) no se ejecutan inmediatamente.

Se "guardan para su uso posterior" y se ejecutarán más tarde, es
decir, cuando se llamen.

Para llamar a una función, se escribe el nombre de la función

seguido de los paréntesis ( ) y un punto y coma ;
En el siguiente ejemplo, myFunction( ) se utiliza para imprimir un texto
(la acción), cuando se llama. En el interior main, se llama a myFunction( )
:

void myFunction( ) //Se crea la función

{
cout << "I just got executed!" ;
}

int main( )
{
Ejecución:
myFunction( ); //Se llama a la función creada
return 0;
}
Una función se puede llamar varias veces, como en el siguiente
ejemplo:

void myFunction( )
{
cout << "I just got executed ! \n" ;
}

int main( )
{
myFunction( );
myFunction( );
myFunction( ); Ejecución:
return 0;
}
Nota: Si una función definida por el usuario, como myFunction( ) se declara
después de la función main( ), se producirá un error. Es porque C++ funciona
de arriba a abajo; lo que significa que si la función no se declara antes de main(
), el programa no lo sabe, por ejemplo:

int main( )
{
myFunction( ); // Error
return 0;
}

void myFunction( )
{
cout << "I just got executed !";
Ejecución:
}
Es posible separar la declaración y la definición de la función, para la optimización del
código. Habrá programas de C++ que tienen declaración de función arriba de main( ) y
definición de función a continuación de main( ). Esto hace que el código esté mejor
organizado y sea más fácil de leer, por ejemplo:

void myFunction( ); //Se declara la función

// El método principal
int main( ) {
myFunction( ); //Se llama a la función creada
return 0;
}

// Definición de la función
void myFunction( ) {
cout << "I just got executed !“ ; Ejecución:
}
 Tipos de Funciones
Los tipos de funciones en C++ son 4, aunque en realidad son las
combinaciones de las 2 cosas que una función puede hacer. Una
función puede hacer (o no) dos cosas: 1 – Recibir datos y 2 –
Retornar datos.

De esto surgen los cuatro tipos de funciones:

1. No reciben ni retornan.
2. Reciben y no retornan.
3. No reciben y retornan.
4. Reciben y retornan.
A continuación, vamos a realizar un
programa que sume dos números,
usando los cuatro tipos de funciones.
 No reciben ni retornan
Son las más sencillas, para usarlas sólo tenemos que saber cómo crearlas y
cómo llamarlas. Una función se crea de esta forma general:
tipo nombre( ){ }

El ‘tipo’ se refiere al tipo de dato (int, float, void, char) y en las funciones que
no retornan siempre es void.

El ‘nombre’ es el nombre de la función: cualquiera que empiece con una letra,

que sea significativo y que no sea una palabra reservada.

Para llamarlas sólo hay que escribir el nombre de la función seguido de sus
paréntesis y un punto y coma( );
nombre( );
#include<iostream>
using namespace std;
void sumar( )
{
int num1, num2, r;
cout<< "num1: ";
cin >>num1 ;
cout <<"num2: "; Todo lo que se habría puesto
en main mejor se puso en una
cin >>num2 ;
función y desde el main la
r = num1 + num2; llamamos.
cout << "La suma es " << r;
} Una función siempre tiene
int main( ) que crearse antes del main.
{
sumar( );
}
 Reciben y No Retornan
Para pedir dos números en el main y que la función haga la suma, tenemos que
crear una función capaz de recibir datos, entonces la sintaxis cambia un poco:
tipo nombre(tipo_var1 nombre_var1, tipo_var2 nombre_var2) { }

‘tipo’ y ‘nombre’ se refieren a lo mismo y como no retorna el tipo siempre es

void. Dentro del paréntesis tenemos otros aspectos: ‘tipo_var1′ se refiere al tipo
de la variable que nuestra función va a recibir. ‘nombre_var1′ se refiere al nombre
de esa variable.
Si queremos recibir una variable hasta ahí es suficiente, si queremos otra variable
ponemos una coma (,) y declaramos la siguiente variable. Para llamar la función
hay que poner las variables que vamos a enviar dentro del paréntesis en el mismo
orden en que las declaramos en la función:
nombre(var1, var2);
#include <iostream>
using namespace std;
void sumar(int num1, int num2)
Pedimos los dos números en
{
el main, los enviamos a la
int r; función, ésta los suma y los
r = num1 + num2; muestra.
cout << "La suma es " << r;
}
int main()
{
int num1, num2;
cin>> num1;
cin>> num2;
sumar(num1, num2);
}
 Retornan y No Reciben
Ahora se desea lo contrario, pedir los números en la función, pero mostrar el resultado en el main.
Para eso se necesita una función que retorne.
Recibir es enviar datos del main a la función. Retornar es enviar datos de la función al main. Para
retornar datos hay que hacer dos cosas: no usar void como tipo y usar return. De forma general:
tipo nombre( ) { return var; }
El ‘tipo’ tiene que ser del tipo de variable que queremos retornar, si la variable retorna una variable
int, pues el tipo de la función es int. Para indicar qué variable se está retornando se usa la palabra
return seguido de la variable. Usualmente esto va al final de la función. Para llamar a la función hay
que preparar un colchón en donde caiga la variable que está retornando.
var = nombre( );

La variable que está retornando la función se va a almacenar en la variable ‘var’. Se debe

recordar que las variables declaradas entre dos llaves { } únicamente existen entre esas dos
llaves. O sea que la variable ‘var’ de la función no es la misma que la variable ‘var’ de la
función main; sin embargo, la var del main está adquiriendo el valor de la var de la función.
#include <iostream>
using namespace std;
int sumar( )
{
int num1, num2, r;
cin>> num1;
cin>> num2;
r = num1 + num2;
return r;
}
int main( )
{
int r;
r = sumar( );
cout << "La suma es " << r;
}
 #include <iostream>
Reciben y Retornan using namespace std;
int sumar(int num1, int num2)
Ahora se desea que la función {
únicamente sume, el main se va a int r;
encargar de pedir los números y sumar r = num1 + num2;
los resultados. Para eso necesitamos return r;
que la función reciba las variables y }
además retorne el resultado. Es sólo int main()
cuestión de combinar las funciones que {
int num1, num2, r;
reciben y no retornan con las que
cin>> num1;
retornan y no reciben.
cin>> num2;
r = sumar(num1, num2);
cout << "La suma es " << r;
}
Conclusión

El sustento teórico aprendido servirá de fundamento para la

implementación de métodos o funciones con pase de parámetros en
la resolución de problemas del contexto.
 Fuentes de Información Bibliográficas:

• Joyanes, L. (2020) Fundamentos de programación: algoritmos,

estructura de datos y objetos - 5ta edición -. España: McGraw-
Hill.
• Tecnológico Nacional de México. “Modularidad en Plan de
Estudios de Fundamentos de Programación.“ TecNM 2016.
Web.
 Instituto Tecnológico de
Matamoros

Gracias.
Instituto Tecnológico de Matamoros
MTE. Laura Alejandra Rosario López