Captulo 4

CONTENIDO PROGRAMTICO

Diseo Descendente de Programas (Top-Down)

Principio Bsico: "Resolver un problema complejo es ms fcil, sino necesitamos considerar todos los aspectos del problema simultneamente" Este principio es vlido solo para problemas que pueden ser fragmentados (particionados). Justificacin: C( P1 ) > C( P2 ) por lo tanto: E( P1 ) > E( P2 ) { lleva ms esfuerzo resolver un problema difcil } Ahora, experimentalmente se ha comprobado que: C( P1 + P2 ) > C( P1 ) + C( P2 ) entonces: E( P1 + P2 ) > E( P1 ) + E( P2 ) ( 2 ) { "Divide y vencers" }

Ventajas a) Simplificar el problema original b) Obtener partes (mdulos) de tamao pequeo, lo cual proporciona: c) Trabajo en Equipo Mayor manejabilidad Facilidad de escritura Facilidad de modificacin Facilidad de Depuracin

Conceptos Derivados

Lic. Pilar Sagals

Pg. 1

Mdulo "La modularidad es el atributo ms sencillo del software que permite a un programa ser manejable intelectualmente (Myers, Composite Structured Design)" "Componente de un programa (parte de...)" Nmero ptimo de Fragmentacin "Es el nmero de partes o mdulos en la cual se debe fragmentar un problema para minimizar su complejidad (y por lo tanto el esfuerzo para resolverlo)".

Principio de Ocultamiento de Informacin "Toda la informacin ( procedimientos + datos ) de un mdulo deber ser privada, a menos de que especficamente sea declarada pblica"

Ocultacin de Informacin "Proceso de diseo que orienta a que cada mdulo del sistema oculte los detalles internos de sus procesos, comunicndose los mdulos solo mediante interfaces bien definidas"

Programa Principal y Subprogramas El fragmentar un problema de programacin en varios subproblemas nos conduce a los siguientes conceptos:

Programa Principal:

Lic. Pilar Sagals

Pg. 2

Es aquel que puede ser activado mediante una instruccin directa del usuario o de una llamada efectuada desde otro programa principal. El programa principal puede pasar al subprograma datos (tambin llamados parmetros de paso) a ms del control de ejecucin. Mientras el subprograma se ejecuta, el programa principal queda en estadosuspendido. Cuando el subprograma termina su trabajo, devuelve el control de ejecucin al programa principal, especficamente a la instruccin que aparece a continuacin de aquella que contena la "llamada" al subprograma.

SubPrograma: Es aqul que solo puede ser activado mediante una "llamada" de un programa principal o de otro subprograma. Al ser activado recibe el control de ejecucin y una lista de valores y/o direcciones de memoria llamados parmetros (que pueden ser de entrada y/o de salida), los cuales debe utilizar para cumplir con la tareas para el cual fue diseado. Cuando termina su trabajo devuelve el control de ejecucin al programa principal o al subprograma que lo llam, pudiendo devolver valores (parmetros de salida). Un subprograma se puede implementar (construir) como:

Procedimento o subrutina:

Es un subprograma que puede recibir y devolver mltiples valores de entrada y salida. Funcin:

Es un subprograma que puede recibir mltiples valores de entrada pero devuelve un solo valor de salida. Su llamada puede indicarse dentro de una expresin aritmtica o lgica. Esto constituye una diferencia operativa fundamental con relacin a un procedimiento, el cual no puede activarse dentro de una expresin aritmtica o lgica, sino solo como una instruccin completa en s misma.

Compartiendo Valores entre Programas y Subprogramas

Lic. Pilar Sagals

Pg. 3

Los programas y subprogramas pueden "compartir" y/o "pasarse" entre s valores mediante alguna de las siguientes formas:

Variables Globales:

Son aquellas cuyos valores estn disponibles (son accesibles) permanentemente para todos los programas y subprogramas. El contenido de una variable global puede ser modificado o ledo por cualquier programa o subprograma, salvo que explcitamente la variable sea declarada de slo-lectura (read-only), caso en el cual slo el programa que la declar puede modificar su valor (los dems slo pueden tomar su valor (leerla)).

Paso de Parmetros:

Son los valores y/o direcciones de memoria que se comparten "transitoriamente" (durante el tiempo que dura la conexin o "llamada") entre programas y subprogramas. Existen dos tipos bsicos de parmetros:

a ) Parmetros formales: Son aquellos que se declaran en el subprograma llamado. Pueden "recibir" y/o "enviar" valores "desde/hacia" el programa que lo llam. Se los considera estticos porque una vez declarados ya no pueden cambiarse durante la sesin de ejecucin.

b) Parmetros actuales: Son aquellos que se declaran y utilizan en el programa o subprograma llamante. Pueden ser variables o constrantes que se indican en la instruccin que activa el (llama al) subprograma que se desea utilizar. Los nombres de las variables/constantes pueden cambiar entre una instruccin de llamada y otra. Por ese motivo se dice que son dinmicos.

Modos de Pasar de Parmetros

Lic. Pilar Sagals

Pg. 4

El paso de parmetros puede realizarse bsicamente utilizando una de las maneras siguientes:

a) Por Referencia: Es cuando una variable perteneciente al programa que llama (parmetro actual) se asocia a un parmetro formal del subprograma llamado. Esto implica que al activarse el subprograma llamado no se crea una posicin de almacenamiento en su memoria local sino que solo se guarda una referencia o puntero a la posicin de almacenamiento correspondiente al parmetro actual ubicada en la memoria local del programa llamante. Su utilizacin supone un ahorro de memoria, pues la variable que hace el papel de parmetro formal no existe fsicamente en el rea de memoria del subprograma llamado. Esto es muy importante cuando se pasan arreglos u objetos complejos que ocupen gran cantidad de memoria.

b) Por Valor: Es cuando el valor de una variable, operacin aritmtica/lgica o constante perteneciente al programa llamante (parmetro actual) se copia en otra variable declarada en el subprograma llamado (parmetro formal). Esto implica que al activarse el subprograma llamado existen temporalmente dos copias del mismo valor, una con el nombre del parmetro actual ubicada en el rea de memoria local del programa llamante, y la otra con el nombre del parmetro formal correspondiente, ubicada en el rea de memoria local del subprograma llamado. Ejemplo del Paso de Parmetros por Referencia y por Valor '*** PROGRAMA PRINCIPAL Inicio: ........... ........... FACTORIAL( M , A ) <----- parmetros actuales [ M....parmetro de entrada ] [ A....parmetro de salida ] FACTORIAL( N , B ) paso por referencia FACTORIAL( ( M - N ) , C ) ............ paso por valor ........... Lic. Pilar Sagals Pg. 5

Fin ' ** SUBPROGRAMA Sub FACTORIAL ( X: entero, F: entero ) <---parmetros formales ........... [ X....parmetro de entrada ] ........... [ F....parmetro de salida ] ........... ........... Fin-sub PROBLEMAS PROBLEMA I Desarrollar un programa que permita calcular la siguiente formula: M! Q = -------------------------N ! x (M - N ) ! donde M! = factorial de M, es decir igual a: 1 x 2 x ... x (M-1) x M N! .... factorial de N. Soluciones Caso 1: utilizando un subprograma implementado como subrutina (procedimiento). '** PROGRAMA PRINCIPAL - Versin en pseudocdigo Inicio: A, B, C, M, N: entero Q: real Leer ( M ) Si M > 0 entonces Leer ( N ) Si N > 0 y N <= M entonces FACTORIAL( M , A ) FACTORIAL( N , B ) FACTORIAL( ( M - N ) , C ) Q=A/B/C Mostrar ( "Q= "; Q ) Fin-si Fin-si Fin '** SUBPROGRAMA Sub FACTORIAL ( X: entero, F: entero ) K: entero F=1 Desde K = 2 hasta X F=F*K Fin-desde Lic. Pilar Sagals Pg. 6

Fin-sub ************************************************************************* ********* '** PROGRAMA PRINCIPAL - Versin en lenguaje QuickBasic INICIO: DIM A AS LONG, B AS LONG, C AS LONG DIM M AS INTEGER, N AS INTEGER, Q AS DOUBLE CLS INPUT "M= "; M IF M > 0 THEN INPUT "N= "; N IF N > 0 AND N <= M THEN CALL FACTORIAL( M , A ) CALL FACTORIAL( N , B ) CALL FACTORIAL( ( M - N ) , C ) Q=A/B/C PRINT "Q= "; Q END IF END IF END '** SUBPROGRAMA SUB FACTORIAL ( X AS INTEGER, F AS LONG ) DIM K AS INTEGER F=1 FOR K = 2 TO X F=F*K NEXT END SUB Caso 2: utilizando un subprograma implementado como funcin. ' ** PROGRAMA PRINCIPAL - Versin en pseudocdigo Inicio: A, B, C, M, N: entero Q: real Leer ( M ) Si M > 0 entonces Leer ( N ) Si N > 0 y N <= M entonces A = FACTORIAL( M ) B = FACTORIAL( N ) C = FACTORIAL( ( M - N ) ) Q=A/B/C Mostrar ( "Q= "; Q ) Fin-si Fin-si Lic. Pilar Sagals Pg. 7

Fin '** SUBPROGRAMA Funcion FACTORIAL ( X: entero ) retorna entero K, F: entero F=1 Desde K = 2 hasta X F=F*K Fin-desde Retornar ( F ) Fin-funcion ************************************************************************* ****************** ********* '** PROGRAMA PRINCIPAL (implementacin alternativa para el Caso 2) Inicio: M, N: entero Q: real Leer ( M ) Si M > 0 entonces Leer ( N ) Si N > 0 y N <= M entonces Q = FACTORIAL( M ) / FACTORIAL( N ) / FACTORIAL( ( M -N)) Mostrar ( "Q= "; Q ) Fin-si Fin-si Fin ************************************************************************* ****************** ********* '** PROGRAMA PRINCIPAL - Versin en lenguaje QuickBasic INICIO: DIM A AS LONG, B AS LONG, C AS LONG DIM M AS INTEGER, N AS INTEGER, Q AS DOUBLE CLS INPUT "M= "; M IF M > 0 THEN INPUT "N= "; N IF N > 0 AND N <= M THEN A = FACTORIAL( M ) B = FACTORIAL( N ) C = FACTORIAL( M - N ) Q=A/B/C PRINT "Q= "; Q END IF END IF END Lic. Pilar Sagals Pg. 8

FUNCTION FACTORIAL# (X AS INTEGER) DIM K AS INTEGER, F AS LONG F=1 FOR K = 2 TO X F=F*K NEXT FACTORIAL# = F END FUNCTION ************************************************************************* ****************** ********* '** PROGRAMA PRINCIPAL (implementacin alternativa para el caso 2) INICIO: DIM M AS INTEGER, N AS INTEGER, Q AS DOUBLE CLS INPUT "M= "; M IF M > 0 THEN INPUT "N= "; N IF N > 0 AND N <= M THEN Q = FACTORIAL( M ) / FACTORIAL( N ) / FACTORIAL( M N) PRINT "Q= "; Q END IF END IF END ************************************************************************* ****************** ********* PROBLEMA II Desarrollar un programa que permita ordenar alfabeticamente una lista de nombres utilizando un arreglo unidimensional ( Vector ). '** PROGRAMA PRINCIPAL - Versin en pseudocdigo Inicio: NOMBRES: arreglo (1 a 100) de cadena N: entero Leer ( "Cantidad de nombres de la lista? (1-100): ", N ) Si N > 0 y N <= 100 entonces LEERVECTOR ( NOMBRES( ) , N ) ORDENARVECTOR( NOMBRES( ) , N ) MOSTRARVECTOR( NOMBRES( ) , N ) Sino Mostrar ( "ERROR - La cantidad es menor a 1 o mayor a 100" ) Fin-si Fin '** SUBPROGRAMAS

Lic. Pilar Sagals

Pg. 9

Sub LEERVECTOR ( V: arreglo(*) de cadena, N: entero ) I: entero Desde I = 1 hasta N Leer ( V( I ) ) Fin-desde Fin-sub Sub MOSTRARVECTOR ( V: arreglo(* ) de cadena, N: entero ) I: entero Desde I = 1 hasta N Mostrar ( V( I ) ) Fin-desde Fin-sub Sub ORDENARVECTOR ( V: arreglo(* ) de cadena, N: entero ) I, J: entero Desde I = 1 hasta N - 1 Desde J = I + 1 hasta N Si V( I ) > V( J ) entonces Intercambiar ( V( I ), V( J ) ) Fin-desde Fin-desde Fin-sub '** PROGRAMA PRINCIPAL - Versin en lenguaje QuickBasic INICIO: DIM NOMBRES (1 TO 100) AS STRING DIM N AS INTEGER CLS INPUT "Cantidad de nombres de la lista? (1-100): ", N IF N > 0 AND N <= 100 THEN CALL LEERVECTOR ( NOMBRES( ) , N ) CALL ORDENARVECTOR( NOMBRES( ) , N ) CALL MOSTRARVECTOR( NOMBRES( ) , N ) ELSE PRINT "ERROR - La cantidad es menor a 1 o mayor a 100" END IF END '** SUBPROGRAMAS SUB LEERVECTOR ( V( ) AS STRING, N AS INTEGER ) DIM I AS INTEGER FOR I = 1 TO N INPUT V( I ) NEXT END SUB

Lic. Pilar Sagals

Pg. 10

SUB MOSTRARVECTOR ( V( ) AS STRING, N AS INTEGER ) DIM I AS INTEGER FOR I = 1 TO N PRINT V( I ) NEXT I END SUB SUB ORDENARVECTOR ( V( ) AS STRING, N AS INTEGER ) DIM I AS INTEGER, J AS INTEGER FOR I = 1 TO N - 1 FOR J = I + 1 TO N IF V( I ) > V( J ) THEN SWAP V( I ), V( J ) ' intercambia los valores ) y V(J) NEXT J NEXT I END SUB

Lic. Pilar Sagals

Pg. 11