Instituto Tecnológico de los Mochis

Nombre: Soberanes López Carmen

Johana
Numero de control:20440834
Carrera: Ingeniería química
Grupo: c3k
Materia: programación
Profesor: Edgard Gómez
Evidencia: unidad 4
“Modularidad”
Modularidad
Un módulo es un componente de un sistema
más grande y opera dentro del sistema
independientemente de las operaciones de
otros componentes.

La modularidad es una opción importante

para la escalabilidad y comprensión de
programas, además de ahorrar trabajo y
tiempo en el desarrollo.

4.1 Optimización de código

La fase de optimización de código independiente de
la máquina trata de mejorar el código intermedio, de
manera que se produzca un mejor código destino. Por
lo general, mejor significa más rápido, pero pueden
lograrse otros objetivos, como un código más corto, o
un código de destino que consuma menos poder. Por
ejemplo, un algoritmo directo genera el código
intermedio, usando una instrucción para cada
operador en la representación tipo árbol que produce
el analizador semántico.

Un algoritmo simple de generación de código intermedio, seguido de la

optimización de código, es una manera razonable de obtener un buen
código de destino.
 Ejemplo de una optimización de bucles: la
variable i sólo se utiliza para calcular la variable
t. Modificando el código podemos actualizar el
valor de t en cada iteración, ahorrándonos una
multiplicación

Existen diferentes técnicas para optimizar el código, cada una de las cuales
intenta mejorar un aspecto diferenciado del código. En general pueden
clasificarse en dos categorías, las de flujo de datos (data-flow) y las de flujo
de control (control-flow).

Pretenden mejorar la eficiencia de Intentan utilizar las

los diferentes cálculos realizados
en el programa: precalculando
expresiones con valor conocido en
tiempo de compilación,
reaprovechando cálculos ya
realizados en otras partes del
código o suprimiendo cálculos
innecesarios.
instrucciones de salto
condicional e incondicional de
la forma más eficiente posible
(ya sea desplazando código o
eliminando saltos innecesarios).
Puede definirse también una
tercera categoría, las
optimizaciones de bucles (loop
optimization), intenta mejorar el
rendimiento de las
instrucciones iterativas como
for, while … do o repeat … until.
 TOP
4.2 Descomposición funcional
Es el proceso mediante el cual un problema se
descompone en una serie de niveles o pasos
DOWN
sucesivos de refinamiento (stepwise). El diseño
descendente es una técnica que permite diseñar la
solución de un problema con base en la • El programa
modularización o segmentación dándole un enfoque principal o de
de arriba hacia abajo (Top Down Design). Esta control se prueba
solución se divide en módulos que se estructuran e en primer lugar
integran jerárquicamente, como si fuera el • Los módulos se
organigrama de una empresa. integran uno por
uno
• Se hace hincapié
en las pruebas de
las interfaces

El diseño se basa en la realización de diferentes niveles.

El primer nivel resuelve totalmente el problema y el
segundo y sucesivos niveles son refinamientos
sucesivos del primero (stepwise) y se sigue siempre la
metodología de recursos abstractos.

Si el diseño y planteamiento es correcto nunca será preciso volver atrás ya

que los niveles anteriores al que se esté situando en un momento dado ya
habrán resuelto el problema en su totalidad.

4.3 Rutinas, funciones y procedimientos

Parte de un programa que se encarga de realizar tareas
repetitivas. Se trata de un conjunto de instrucciones que
realizan una función muy concreta dentro de un programa o
en un dispositivo hardware. Por ejemplo, una rutina puede ser
la función de imprimir dentro de un procesador de texto.
Un procedimiento es un subprograma
que ejecuta una tarea determinada.
Este compuesto por un conjunto de
sentencias, a las que se les asigna un
nombre o identificador. Constituyen
unidades del programa, y su tarea se
ejecuta siempre y cuando encuentre
el nombre que se le asigno a dicho
procedimiento.

Función factorial (n:entero):entero

Una función no es más que var i,factorial:entero
un conjunto de líneas de inicio
si n <=1 entonces
código que hacen una tarea
factorial <-- 1
en concreto, y esta función sino
puede retornar un valor… factorial <-- 1
Las funciones tienen la desde i = 1 hasta n hacer
factorial <-- factorial * 1
posibilidad de tener fin_desde
parámetros o argumentos, fin_si
que son variables que fin

modifican su Evaluar la función f = x! / (y!(x-

comportamiento. y)!)
Algoritmo hallarf
var x,y:entero
f:real
inicio
leer (x,y)
f <-- factorial (x)/(factorial (y)*
factorial (x-y))
escribir ("El valor de f es:", f)
fin
 • Facilitan el diseño top-down.
• Se pueden ejecutar mas de una vez en un
programa, con solo llamarlos las veces que
así desee. Con esto se ahorra tiempo de
programación.
• El mismo procedimiento se puede usar en
distintos programas.
• Su uso facilita la división de tareas entre los
programadores de un equipo.
• Se pueden probar individualmente e
incorporarlos en librerías o bibliotecas.

4.4 Paso de argumentos

Existen diferentes formas
de pasar un argumento a
una función (subrutina) o
procedimiento: por valor,
por referencia, por
resultado, por valor-
resultado y por nombre.
El paso de parámetros por valor
consiste en copiar el contenido de
la variable que queremos pasar en
otra dentro del ámbito local de la
subrutina, consiste pues en copiar
el contenido de la memoria del
argumento que se quiere pasar a
otra dirección de memoria,
correspondiente al argumento
dentro del ámbito de dicha
subrutina. Se tendrán dos valores
duplicados e independientes, con lo
que la modificación de uno no
afecta al otro.
El paso de parámetros por referencia consiste en proporcionar a la
subrutina a la que se le quiere pasar el argumento la dirección de
memoria del dato. En este caso se tiene un único valor referenciado (o
apuntado) desde dos puntos diferentes, el programa principal y la
subrutina a la que se le pasa el argumento, por lo que cualquier acción
sobre el parámetro se realiza sobre la misma posición de memoria.

El paso de la dirección de memoria debe ser transparente al programador. Los lenguajes que permiten
tratar con direcciones de memoria, como C, permiten simular el paso de argumentos por referencia, sin
disponer realmente de esta característica.

Es un tipo poco usado en los

lenguajes de programación
actuales. Se basa en que dentro
de la función se trabaja como si
los argumentos hubieran sido
pasados por valor pero al
acabar la función los valores
que tengan los argumentos
serán copiados a las variables
que pertenecían.

Este tipo puede ser simulado en cualquier lenguaje que permita el

paso de valores.

void EjemploValorRes(int& a1, int& a2, int&

a3) {
int aux1 = a1, aux2 = a2, aux3 = a3;
// código trabajando con aux1, aux2 y
aux3
a1 = aux1; a2 = aux2; a3 = aux3; //
Dependiendo del compilador la copia se
realiza en un sentido o en el otro
}
EJERCICIOS
Realizar un programa que calcule el
número e, utilizando el siguiente
desarrollo en serie: e = 1 + 1/1! + 1/2!+
…+ 1/10! + … El programa debe usar la
función factorial definida en el
ejercicio anterior.

#include <stdio.h>

#include <stdlib.h>

float factorial(int n);

int main()

{ int i,j,n;

float e =1;

do

{ system("cls");

printf("Cálculo del nº e segun la formula:\n\n");

printf("e = 1 + 1/1! + 1/2! + ... + 1/10! + ... \n\n");

printf("Introduce el nº de terminos a usar (max 10):");

scanf("%d",&n);

} while (n<1 || n>10);

 printf("\nFormula: e = 1");

for(i=1; i<=n-1; i++)

{ printf(" + 1/%d!",i);

e = e + 1/factorial(i);

printf("\n\nEl numero e vale %f \n\n",e);

system("pause");

return 0;

float factorial(int n)

{ int i;

float fact=1;

for(i=1; i<=n; i++)

fact=fact*i;

return(fact);

}
 Se busca declarar un tipo de datos stack y además que la
implementación y la estructura de datos quede oculta para los
usuarios.

stack.c

#include

int stack_var1;

static int stack_var2;

int stack_do_something(void)

stack_var1=2;

stack_car2=5;

El archivo principal es el que puede llamar al módulo de stack:

#include

int main(int argc, char * arg[]){

while(1){

stack_do_something();

}
Un correcto diseño modular reduce la
complejidad, facilita los cambios y da como
resultado una implementación más fácil,
posibilitando el desarrollo paralelo de
diferentes partes del sistema, sin embargo es
muy importante tener en cuenta cuando parar
el refinamiento sucesivo para evitar la
aparición de módulos que sean incapaces de
definir una tarea.