Análisis,

Diseño e
Implantación
de Algoritmos
(Intro. a la Solución de Prob. con Comp.)
 Contenido

Unidad 5. FUNCIONES Y PROCEDIMIENTOS.........................................................................4

5.1. Diseño Modular................................................................................................................4
5.1.1. Objetivos de la Modularización.................................................................................5
5.1.2. Módulos.....................................................................................................................5
5.2. Diagramas o Cartas de Estructura...................................................................................8
5.2.1. Estructuras de Decisión.............................................................................................9
5.2.2. Intercomunicación de Módulos................................................................................10
5.3. Funciones.......................................................................................................................10
5.3.1. Declaración de Funciones.......................................................................................11
5.3.2. Llamada a las funciones..........................................................................................11
5.4. Procedimientos...............................................................................................................11
5.4.1. Declaración de Procedimientos...............................................................................11
5.4.2. Llamada a los procedimientos.................................................................................11
5.5. Diferencias entre Funciones y Procedimientos.............................................................12
5.6. Variables Locales y Globales.........................................................................................12
5.7. Parámetros.....................................................................................................................12
5.7.1. Clasificación de los parámetros..............................................................................13
5.7.2. Paso de parámetros por valor.................................................................................13
5.7.3. Paso de parámetros por referencia.........................................................................13
5.8. Funciones Internas.........................................................................................................14
5.9. Recursividad...................................................................................................................14
  OBJETIVO DE LA UNIDAD

Al término de esta unidad, el alumno:

 Creará funciones y procedimientos definidos por el usuario

 Distinguirá la diferencia entre variable locales y globales
 Establecerá el modelo de paso de parámetros
 Especificará módulos recursivos
 Conocerá las funciones internas de la mayoría de los lenguajes de
programación
 Creará programas modulares
 Unidad 5. FUNCIONES Y PROCEDIMIENTOS

La solución de programas se facilita al dividirlos en problemas más pequeños (subprogramas). El uso de

subprogramas permite desarrollar programas complejos mediante el método top-down. Los subprogramas
pueden ser de dos tipos: funciones y procedimientos (subrutinas). Los subprogramas son unidades de
programa o módulos que están diseñados para ejecutar una sola tarea específica. Estos subprogramas se
escriben una vez y pueden ser usados varias veces en diversos puntos de un programa, evitando la duplicación
de código.

El problema principal se soluciona por el correspondiente programa principal (controlador) y la solución de los
subproblemas mediante subprogramas (procedimientos o funciones). Un subprograma puede realizar las
mismas acciones que un programa pero es utilizado (llamado o invocado) por un programa para un propósito
específico. El subprograma recibe datos desde el programa principal y devuelve el control al programa junto con
resultados. Esto puede realizarse en diversos lugares del programa y cada vez que el subprograma es llamado,
el control retorna al lugar de donde se realizó la llamada. Un subprograma puede llamar a su vez a otros
subprogramas e incluso llamarse a sí mismo.

1. Diseño Modular
La clave para la construcción de programas es la descomposición del proceso en módulos de una sola tarea
comprensible, y estructurar estos módulos para proporcionar una implementación elegante de la solución del
problema. Desafortunadamente, no existe una fórmula para descomponer un programa complejo en tareas
individuales.

Una técnica de diseño de programas, que resulta ser el método más simple y uno de los más populares es el
conocido como de "Refinamiento Progresivo" propuesta por Niklaus Wirth. El proceso se puede describir en
términos de algoritmos y primeramente consiste en establecer todos los pasos del programa en un algoritmo
breve de alto nivel. Después se expande cada sentencia del algoritmo en detalle, aplicando el estudio
descendente Top-Down, especificando los pasos necesarios a cada subproblema una y otra vez, hasta que las
tareas hayan sido especificadas con el detalle suficiente para poder codificar el programa.

Otra metodología más depurada es la "Descomposición Funcional". A diferencia de la anterior en cada etapa se
especifican las propiedades esenciales de las estructuras de datos, y cada algoritmo se expresa como una
función que transforma esta estructura de datos.

Las estrategias, sin embargo, consisten en la reducción arriba-abajo (top-down) del procesamiento hasta
alcanzar un nivel donde cada proceso individual consista de una sola tarea que sea entendible y pueda ser
programada relativamente en pocas líneas de código.

El nivel de descomposición en módulos es un proceso iterativo. Presupone el conocimiento del lenguaje de

programación a usar e inicialmente puede ocurrir que se ponga demasiado poco o mucho código en un módulo
individual. También es una capacidad que se mejora con forme se van escribiendo más programas, sin
embargo, siempre será mejor errar por usar muchos módulos simples, que pocos módulos muy complejos.
También puede suceder que se diseñe un algoritmo con un lenguaje específico en mente, es preferible evitarlo
y describir el proceso en términos generales que sean capaces de ser implementados en cualquier lenguaje.

Un programa bien estructurado satisface las siguientes condiciones:

 El programa ha de tener una estructura general en forma de módulos, que a su vez estarán formados
por procedimientos o segmentos.
 Debe existir una interfaz claramente definida (parámetros) entre los diversos módulos.
 Cada módulo debe de ser una combinación sencilla de construcciones elementales de programación.
 Debe existir una fuerte correspondencia entre la estructura de los módulos y la de los datos sobre los
que operan.
  Cada módulo debe dejar las estructuras de datos sobre las que opera en un estado consistente con su
definición.
 Un módulo no debe tener efectos secundarios.
1.1. Objetivos de la Modularización
La descomposición de un programa en pequeños módulos se realiza con el fin de lograr:

 Disminuir complejidad
 Aumentar claridad y fiabilidad
 Disminuir costos
 Aumentar control
 Facilitar ampliación
 Facilitar modificación y corrección
1.2. Módulos
Un módulo es una o más instrucciones contiguas y encadenadas que tienen un nombre, realizan una sola tarea
y es llamado desde diversos puntos de un programa.

1.2.1. Tipos de módulos

Los módulos especificados pueden ser de tres tipos:

 Programa – conjunto de instrucciones que sigue la computadora para alcanzar un resultado específico.
 Función - módulo que toma uno o más valores llamados argumentos y produce un valor denominado
resultado.
 Procedimiento - un módulo que ejecuta un proceso específico y no retorna algún valor

1.2.2. Características
A su vez, todos los módulos deben tener

 Máxima cohesión (asociación de los elementos dentro del módulo)

 Mínimo acoplamiento (interdependencia de los módulos)
 Máximo fan-in
 Equilibrado fan-out

Para evaluar que el diseño estructurado sea correcto, se emplean los conceptos de acoplamiento y cohesión;
estos conceptos están fuertemente relacionados entre sí y no es posible cuantificarlos. También se debe
considerar el grado de fan-in y fan-out.

El acoplamiento es el grado de interdependencia que existe entre los módulos de un programa. Lo ideal es que
el acoplamiento sea mínimo para permitir la reutilización de esos módulos en diversos programas. Los niveles
de acoplamiento, del más deseable al menos deseable son:

 Acoplamiento normal.- Un módulo llama a otro de un nivel inferior y tan solo intercambian datos
(parámetros de entrada/salida). Dentro de este tipo de acoplamiento existen tres subtipos, dependiendo
de los datos que intercambien los módulos:

o Acoplamiento de datos: Los módulos se comunican mediante parámetros.

 o Acoplamiento de marca o por estampado: Los módulos se pasan datos con estructura de
registro. No es muy deseable si el módulo receptor sólo requiere parte de los datos que se le
pasan.
o Acoplamiento de control: Los datos que se intercambian entre los módulos son controles.
Debido a que en este subtipo un módulo controla la ejecución del otro, no es un buen
acoplamiento, ya que impide que sean totalmente independientes.

 Acoplamiento Común.- Dos módulos acceden a un mismo recurso común, típicamente memoria
compartida, una variable global o un archivo. Una variante de este tipo de acoplamiento es el
acoplamiento externo:

o Acoplamiento externo.- Los módulos están ligados a componentes externos. Por ejemplo,
dispositivos de E/S, protocolos de comunicaciones... etc.

 Acoplamiento de contenido.- Ocurre cuando un módulo necesita acceder a una parte de otro módulo.

La cohesión es la medida de relación funcional entre las instrucciones o grupos de instrucciones dentro de un
módulo. Un módulo coherente ejecuta una única tarea sencilla, interactuando muy poco o nada con el resto de
los módulos del programa. Lo ideal es tener una alta cohesión. Existen siete tipos de cohesión, ordenados del
mejor al peor modelo de cohesión.

 Cohesión funcional: Los elementos del módulo están relacionados en el desarrollo de una única
función.
 Cohesión secuencial: Un módulo realiza distintas tareas en secuencia, de forma que las entradas de
cada tarea son las salidas de la tarea anterior. No es una mala cohesión si las tareas implicadas no son
muy complejas y requieren pocas líneas de código.
 Cohesión comunicacional: El módulo realiza actividades paralelas usando los mismos datos de
entrada y salida. Como en el caso anterior, tampoco se trata de un mal tipo de cohesión si las tareas
son relativamente sencillas.
 Cohesión procedimental: El módulo tiene una serie de funciones relacionadas por un procedimiento
efectuado por el código (a modo de biblioteca). Es similar a la secuencial, pero puede incluir el paso de
controles. Será deseable que las funciones estén relacionadas o realicen tareas dentro del mismo
ámbito (p.e. la biblioteca string.h de C contienen funciones para operar con cadenas de caracteres).
 Cohesión temporal: Los elementos del módulo están implicados en actividades relacionadas con el
tiempo. Por ejemplo se realizan todas al ingresar al sistema.
 Cohesión lógica: Las actividades que realiza el módulo tienen la misma categoría. Es como si se
tuvieran partes independientes dentro del mismo módulo. Por ejemplo, todas las operaciones
aritméticas en un solo módulo.
 Cohesión casual o coincidente: Los elementos del módulo contribuyen a las actividades
relacionándose mutuamente de una manera poco significativa. Este tipo de cohesión viola el principio
de independencia y de caja negra de los módulos.

Además del acoplamiento y cohesión, se deben tener en cuenta el grado de absorción (fan-in) y la diseminación
de control (fan-out) de los módulos para garantizar la calidad del diseño.

El fan-in o grado de absorción, es el número de padres inmediatos que tiene un módulo. Es conveniente
maximizar el fan-in ya que cada instancia de fan-in múltiple, indica que se ha evitado duplicar el código,
logrando reutilización.

El fan-out o diseminación de control, es el número de hijos inmediatos que tiene un módulo. Es conveniente
mantener un fan-out equilibrado (ni muy alto, ni muy bajo) ya que eso es un posible indicador de un diseño
pobre.
1.2.3. Clasificación de acuerdo a sus funciones
Los módulos que pueden clasificarse dependiendo de la función que realiza en los siguientes tipos:

 Raíz o principal – módulo donde inicial el programa

 Subraíz – generalmente un submenú que permite seleccionar alguna función sobre un tipo de dato en
particular.
 Entrada – permite el ingreso de datos por el usuario.
 Variación de entradas – toma los valores de entrada del usuario y los convierte en los valores que se
almacenan.
 Proceso – transformación de los datos de entrada en datos de salida y almacenamiento.
 Creación y formatos de salidas – especifica las características para mostrar los datos, ya sea en
pantalla o en papel (impresión).
 Validación – verifica los valores ingresados

1.2.4. Pasos para la modularización

Para lograr una buena modularización se realizan los siguientes pasos:

 Establecer un organigrama modular

 Describir el módulo principal
 Describir los módulos secundarios
 Emplear normas de programación

Se debe recordar que el proceso total es iterativo. No se puede esperar llegar al diseño apropiado en el primer
intento. Se debe estar preparado para rediseñar la jerarquía o la secuencia de las operaciones e incluso para
reagrupar o subdividir funciones donde la estructura lo requiera para obtener resultados eficientes.

1.2.5. Técnicas de programación modular

Además de realizar esos pasos se pueden aplicar las siguientes técnicas de programación modular

 Diseño descendente (top-down)

 Montaje ascendente (bottom-up) – empezar a programar los niveles más bajos
 Cada módulo sólo tiene una entrada y una salida
 Siempre habrá un modulo principal
 Los datos pueden ser internos (locales) o externos (globales), pero para evitar un alto acoplamiento es
preferible usar variables locales.

1.2.6. Criterios de modularización

Se debe recordar que cada módulo debe cubrir los siguientes criterios

 Cada módulo debe realizar sólo una función

 Cada módulo debe tener máximo una página de instrucciones (50 renglones máximo)
 Se deben evitar las variables externas (globales)
 Evitar demasiados niveles de modularización
 Estructura de caja negra para cada módulo (no debe ser importante para el usuario cómo se resuelve el
problema, sino cómo se usa)

2. Diagramas o Cartas de Estructura

Una vez descompuesto el problema en un número de módulos individuales, se requieren realizar dos pasos
antes del codificar el código: definir la relación de los módulos con otros en términos de jerarquía y su secuencia
de operación, y definir su intercomunicación.

Los propósitos de los diagramas o cartas de estructura son:

1. Obtener una estructura aceptable para el programa definiendo sus módulos componentes y su
interacción mutua.
2. Generar de manera semiautomática el algoritmo del programa, implementando las estructuras de
control indicadas en el diagrama de estructura.

De las herramientas de diseño de programas actualmente disponibles, una de las mejores para determinar e
ilustrar la estructura de un programa son los diagramas de estructura.

Un diagrama de estructura muestra la composición de un programa en términos de su jerarquía y secuencia

de operaciones. No intenta desplegar el diseño individual de los algoritmos como una descripción de la lógica
de solución del problema.

El diagrama comprende una estructura tipo árbol con el nombre del programa en una caja en la parte superior y
cada módulo en una caja subordinada a su “administrador” o “controlador”. Una iteración o ciclo se indica
mediante una flecha semicircular sobre las líneas de control dibujadas desde un controlador a sus
subordinados. Una selección se obtiene usando el símbolo de diamante (rombo) tradicionalmente usado para
representar las decisiones en diagramas de flujo. Además de estos símbolos, las únicas reglas de interpretación
son que la jerarquía se representa de arriba hacia abajo y la secuencia es leída de izquierda a derecha.

Con forme se desciende en la estructura jerárquica del programa, se verán cambios en la naturaleza de las
instrucciones contenidas en los módulos. El nivel más alto de los módulos debe contener instrucciones de
“administración” (decisiones y direcciones a subordinados); con forme bajamos en la jerarquía, gradualmente
más y más instrucciones de “trabajo” serán descritas en los módulos (cálculos, movimiento de datos, etc.). Se
debe evitar introducir instrucciones de trabajo en los niveles más altos de la jerarquía. Probablemente, el primer
y posiblemente el segundo nivel de módulos consistirán sólo de instrucciones de repetición y condiciones
(menús).

Algoritmo A A
Inicio
Ejecutar P
Ejecutar Q
Ejecutar R
Fin P Q R

Secuencia
Algoritmo A
Mientras condición
Ejecutar P A
Ejecutar Q
Ejecutar R
Fin Mientras
P Q R
P
Iteración

Algoritmo A
Si Condición A
Ejecutar P
 Fin Si

P
Condición
Se debe evitar colocar grandes grupos de instrucciones de trabajo en una decisión. Es mas limpio removerlos y
colocarlos en un módulo subordinado.

Algoritmo (primer nivel)

Mientras Condición
Ejecutar B
Si Condición
Ejecutar C
De lo contrario
Ejecutar D
Fin Si
Fin Mientras

2.1. Estructuras de Decisión

Una carta de estructura da oportunidad de revisar las estructuras de decisión de un programa y reordenarlas, si
es necesario, antes de implementar el algoritmo.

Es necesario considerar dos aspectos al examinar la estructura de control en un programa:

1) Tratar de eliminar las evaluaciones repetitivas de una condición:

Estrategia 1 (Pobre)
Calcular Pago
Ejecutar Calcular Nómina
Ejecutar Calcular Impuestos
Ejecutar Calcular Bonos
Calcular Nómina
Si empleado permanente entonces
Ejecutar Calcular Nómina para Empleado Permanente
De lo contrario
Ejecutar Calcular Nómina para Empleado Temporal
Fin si
Calcular Impuestos
Si empleado permanente entonces
Ejecutar Calcular Impuestos para Empleado Permanente
De lo contrario
Ejecutar Calcular Impuestos para Empleado Temporal
Fin si
Calcular Bonos
Si empleado permanente entonces
Ejecutar Calcular Bonos para Empleado Permanente
De lo contrario
Ejecutar Calcular Bonos para Empleado Temporal
Fin si

Estrategia 2 (Mejor)

Calcular Pago
Si empleado permanente entonces
Ejecutar Calcular Pago para Empleado Permanente
De lo contrario
Ejecutar Calcular Pago para Empleado Temporal
Fin si
 Calcular Pago para Empleado Permanente
Ejecutar Calcular Nómina para Empleado Permanente
Ejecutar Calcular Impuestos para Empleado Permanente
Ejecutar Calcular Bonos para Empleado Permanente

Calcular Pago para Empleado Temporal

Ejecutar Calcular Nómina para Empleado Temporal
Ejecutar Calcular Impuestos para Empleado Temporal
Ejecutar Calcular Bonos para Empleado Temporal

2) Se debe asegurar que todo proceso que dependa del resultado de una decisión esté
subordinado al módulo en el cual se toma la decisión.
2.2. Intercomunicación de Módulos
Dado que cada módulo de un programa ejecutará una función, los resultados afectarán uno o varios módulos
del programa. Existen básicamente dos métodos de intercomunicación entre módulos:

1) Comunicación por elementos de datos; y

2) Comunicación por elementos de estado

Para comunicarse entre módulos del programa se utilizan parámetros o argumentos.

Los parámetros pueden tener una de tres funciones:

1) Servir para pasar información al módulo subordinado (subrutina).

2) Regresar información de la subrutina al programa que los llamó.
3) Servir en ambos sentidos pasando información a la subrutina y regresándola.

Estos parámetros se incorporan en una carta de estructura usando los símbolos:

Parámetro de datos

Parámetro de estado

Se debe evitar usar parámetros de datos para indicar también algún estado. Si un parámetro es un elemento
de dato, debe permanecer como tal, o confundirá al lector del diagrama al usarlo para otro fin.

Un parámetro de estado debe contener sólo uno de dos valores posibles, Falso o Verdadero.

3. Funciones
Una función es un módulo que toma uno o más valores llamados argumentos y produce un valor denominado
resultado (valor de la función para los argumentos dados). Todos los lenguajes de programación tienen
funciones internas (incorporadas o intrínsecas) y permiten crear funciones definidas por el usuario (UDFs).

Cada función se invoca usando su nombre en una expresión con los argumentos actuales encerrados entre
paréntesis ( x = SQR(16) ), que deben coincidir en cantidad, tipo y orden con los de la función que fue definida.
Las funciones devuelven un sólo valor.

3.1. Declaración de Funciones

Una función tiene los mismos elementos de un programa: cabecera con la definición de la función y cuerpo de
la función, que serán instrucciones cuya ejecución hará que se asigne un valor al nombre de la función. Esto
define el resultado que devuelve al programa que la llamó.
Los argumentos de la declaración de la función se llaman parámetros formales, ficticios o mudos (“dummy”);
estos son nombres de variables, de otras funciones o procedimientos y que sólo se utilizan dentro del cuerpo de
la función. Los argumentos utilizados en la llamada a la función se llaman parámetros actuales, y que son
variables, expresiones, valores de funciones o nombres de funciones o procedimientos.

3.2. Llamada a las funciones

Para que las acciones descritas en una función sean ejecutadas, se requiere invocar a la función desde un
programa principal o desde otro subprograma a fin de proporcionarle los argumentos de entrada necesarios
para realizar sus acciones.

Cada vez que se llama a una función, se establece una correspondencia entre los parámetros formales y los
actuales, y se presupone una correspondencia uno a uno de izquierda a derecha entre ellos.

Los pasos de una llamada a la función son:

1. A cada parámetro formal se le asigna el valor real de su correspondiente parámetro actual.

2. Se ejecuta el cuerpo de acciones de la función, incluyendo la asignación del resultado al nombre de
función.
3. Se devuelve el valor de la función y se retorna al lugar de la llamada.
4. Procedimientos
Un procedimiento es un módulo o subprograma que ejecuta un proceso específico. Ningún valor se asocia con
el nombre del procedimiento, por lo que no puede llamarse en una expresión. Un procedimiento se llama
escribiendo su nombre con la lista de parámetros que recibe entre paréntesis.

4.1. Declaración de Procedimientos

La declaración de los procedimientos es similar a la de las funciones excepto que los resultados del
procedimiento no se asocian al nombre del mismo.

Los parámetros formales tienen el mismo significado que en las funciones aunque a menudo reciben
parámetros por referencia.

4.2. Llamada a los procedimientos

Un procedimiento se llama mediante su nombre pasándole los parámetros actuales y variables entre paréntesis,
a diferencia de las funciones, estas llamadas no pueden realizarse dentro de una expresión.

5. Diferencias entre Funciones y Procedimientos

Los procedimientos y las funciones son subprogramas cuyo diseño y objetivo son similares; sin embargo,
existen algunas diferencias:

1. Un procedimiento es llamado desde el programa principal mediante su nombre y una lista de

parámetros actuales o bien con la instrucción ejecutar. Al llamar al procedimiento se detiene
momentáneamente el programa que se estaba realizando y el control pasa al procedimiento llamado.
Después que las acciones del procedimiento se realizan, se regresa a la acción siguiente a la que se
llamó.
2. Las funciones devuelven un solo valor, mientras que los procedimientos pueden “regresar” 0, 1 o n
valores en forma de lista de parámetros.
3. El procedimiento se declara igual que la función, pero su nombre no se asocia a ninguno de los
resultados obtenidos.
6. Variables Locales y Globales
Las variables se clasifican en variables locales y globales de acuerdo al ámbito en donde pueden ser accedidas.

Una variable local es aquella que es declarada y definida dentro de un subprograma y es distinta de las
variables con el mismo nombre declaradas en cualquier parte del programa principal. Esta variable sólo existe
dentro del subprograma donde se declara. Si otro subprograma utiliza el mismo nombre, se refiere a una
posición diferente en memoria.

Una variable global es aquella que está declarada para el programa completo.

La parte del programa en que se declara una variable se llama ámbito (alcance).

El uso de variables locales tiene algunas ventajas, hace a los subprogramas independientes, con la
comunicación entre el programa principal y los subprogramas estructuralmente a través de la lista de
parámetros. Para usar un subprograma, sólo necesitamos conocer lo que hace sin preocuparnos de cómo lo
hace.

Si un subprograma asigna un valor a una variable local, este valor no es accesible a otros subprogramas a
menos que estén anidados en el mismo.

Las variables globales tienen la ventaja de compartir información de diferentes subprogramas sin una
correspondiente entrada en la lista de parámetros.

7. Parámetros
La comunicación entre programas y subprogramas se realiza mediante los parámetros formales y actuales.
Existen dos métodos de correspondencia entre parámetros:

1. Correspondencia posicional. Es la que se establece emparejando los parámetros actuales y formales

según su poción en las listas. Este método tiene la desventaja de falta de legibilidad cuando el número
de parámetros es grande.
2. Correspondencia por el nombre explícito. En este caso, la correspondencia entre los parámetros
actuales y formales se indica directamente sin importar el orden en que se pasan.

7.1. Clasificación de los parámetros

Los tipos de parámetros de acuerdo a los datos que recibe y retorna son:
entrada: proporcionan valores desde el programa que llama y que se emplean dentro del
procedimiento. En las funciones, la mayoría de los parámetros son de este tipo.
salida: producen los resultados del subprograma, el caso de las funciones se retorna un solo
valor mediante el nombre de la función; en los procedimientos pueden calcularse 0, 1 o
más salidas.
entrada / salida se emplean para mandar argumentos a un subprograma y devolver resultados.

Los métodos empleados para realizar paso de parámetros son:

 paso por valor
 paso por referencia.
7.2. Paso de parámetros por valor
Estos parámetros se tratan como variables locales cuyos valores iniciales se proporcionan copiando los valores
de los correspondientes argumentos.
Los parámetros formales reciben sus valores iniciales copiando los valores de los parámetros actuales y con
ellos se ejecutan las acciones del subprograma.

Aunque el paso de parámetros por valor es sencillo, no permite alguna otra conexión con los parámetros
actuales, por lo que, los cambios realizados en el subprograma no producen cambios en los parámetros
actuales, estos parámetros son sólo de entrada. La llamada por valor no retorna información al programa que lo
llama.

7.3. Paso de parámetros por referencia

En este caso, el programa que llama, pasa al subprograma la dirección de memoria del parámetro actual. Una
variable pasada como parámetro formal es compartida, es decir, se puede modificar directamente por el
subprograma.

El área de almacenamiento (dirección de memoria) se emplea para pasar información de entrada y / o salida.
Los parámetros son por tanto de entrada / salida.

La llamada por referencia es muy útil para parámetros donde se requiere la comunicación del valor en ambas
direcciones.

La elección entre un método u otro puede ser determinada por diversas consideraciones, como evitar efectos
laterales no deseados provocados por modificaciones inadvertidas de parámetros formales.

No se deben modificar los valores de variables globales directamente dentro de una subrutina.

Toda comunicación entre programa principal y submódulos debe hacerse mediante parámetros formales y no
mediante variables globales. Esto convertirá al subprograma en un módulo independiente que puede ser
comprobado y depurado por sí solo, lo que evita preocuparse por el resto del programa.

8. Funciones Internas
En general, los lenguajes de programación proporcionan un conjunto predeterminado de funciones que
permiten no tener que inventar el hilo negro cada vez que se requiere realizar esa operación.

Por ejemplo, en la mayoría de los lenguajes existe alguna función que permite saber la longitud de una cadena
u obtener el valor absoluto de una expresión o variable numérica.

Estas funciones son llamadas funciones internas y varían de un lenguaje de programación a otro. Así por
ejemplo, en el lenguaje C existen las funciones getche(), abs() y strcmp().

9. Recursividad
Un objeto es recursivo si forma parte de sí mismo o interviene en su propia definición. Un subprograma que
puede llamarse a sí mismo se llama recursivo. La recursión es una herramienta muy potente en aplicaciones
particularmente de cálculo y puede emplearse como alternativa a las estructuras de repetición.

La escritura de subprogramas recursivos es similar a la de los no recursivos; sin embargo, se requiere incluir en
el subprograma una condición de terminación para evitar que la recursión se repita indefinidamente.

El instrumento necesario para expresar los programas recursivos es el subprograma. Existen dos tipos de
recursividad:
  recursividad directa, cuando un subprograma se llama a sí mismo; y
 recursividad indirecta, cuando un subprograma llama a otro y este a su vez llama al primero.

Para entender la recursividad hay que tener en cuenta que:

 Cuando se llama a un subprograma los parámetros y las variables locales toman nuevos valores y el
subprograma trabaja con estos nuevos valores y no con los de las llamadas anteriores.
 Cada vez que se llama a un subprograma los parámetros de entrada y variables locales son
almacenados en las siguientes posiciones libres de memoria y cuando termina la ejecución del
subprograma son accedidos en orden inverso a como se introdujeron.
 El espacio necesario para almacenar los valores crece conforme a los niveles de anidamiento de las
llamadas.
 El cuerpo del procedimiento o función debe disponer de una o varias instrucciones selectivas donde
establecer la condición o condiciones de salida.

Todos los algoritmos recursivos pueden ser implementados en forma iterativa empleando una pila.

Tarea

Leer al menos dos fuentes adicionales sobre los temas vistos en esta unidad y hacer un resumen de esta
unidad (máximo 1 cuartilla de resumen, no olvidar bibliografía y conclusiones -en otra cuartilla).

Además explicar las diferencias entre:

1. Los procedimientos y las funciones
2. Las variables locales y globales
3. Los parámetros y las variable
4. Los argumentos y los parámetros
5. El paso de parámetro por valor y por referencia
6. Un ciclo y la recursividad
7. El acoplamiento y la cohesión