UNIVERSIDAD CENTROAMERICANA

Departamento de Desarrollo Tecnológico

Coordinación ISI
 Programación Modular

La filosofía subyacente de la programación modular, es la

descomposición del programa en módulos independientes, cada uno
de los cuales ejecuta una única actividad o función. Cada módulo se
analiza, se diseña, se codifica y se verifica por separado.
El programa es una jerarquía de módulos, con un módulo principal
(también llamado programa principal) con una función de controlador.
El módulo principal transfiere el control a los módulos inmediatamente
subordinados (o subprogramas), de modo que éstos puedan ejecutar
sus funciones. Una vez que el módulo subordinado haya completado
su tarea, devolverá nuevamente el control al módulo controlador.
La descomposición de un módulo en submódulos continúa hasta que
se llegue a un punto en que el módulo resultante tenga sólo una tarea
específica que ejecutar (lectura, salida de resultados, procesamiento
de datos o control de otros módulos).
 Programación Modular

Nivel 0 de Módulo
Principal Datos
descomposición

Nivel 1 de
descomposición Módulo 1 Módulo 2 Módulo 3

Nivel 2 Módulo 1.1 Módulo 1.2 Módulo 2.1 Módulo 2.2 Módulo 3.1

Nivel 3 de
descomposición Módulo 2.2.1 Módulo 2.2.2 Módulo 3.1.1
Programación Modular
 Programación Modular

 Programación modular:
◦ dividir la complejidad de un problema.
 identificar subproblemas o tareas más simples.
◦ reutilizar el código. ,
m o d ulo p rinc ip al

 Módulo M 1 M 2 M 3

◦ Características básicas: M 1 .1 M 1 .2 M 2 .1 M 3 .1

 Alta cohesión.
M 3.1 .1 M 3.1 .2
 Bajo acoplamiento.
◦ En C/C++ los módulos se implementan como funciones.
◦ Todos los programas contienen al menos la función main.
 Diseño Descendente y Descomposición Modular

 Dividir el problema en subproblemas más sencillos.

 Cada subproblema se codifica como un subprograma o módulo
independiente.
 En programación estructurada, la unidad mínima con sentido y
nombre propio, relativamente independiente del resto, es la
función o el procedimiento.
 Las funciones y procedimientos de un programa, se agrupan en
módulos. Los módulos son unidades lógicas que agrupan
funciones o procedimientos similares o relacionadas.
 El programa consta de unidades de programa tratadas como
piezas que se conectan entre si.
 Pasos del Diseño Modular

Identificar los módulos a partir de los requisitos.

◦ Descomponer cada módulo en sus correspondientes
funciones o procedimientos.
◦ Diseñar el algoritmo para las funciones y procedimientos.
◦ Implementar las funciones y los procedimientos.
 Ventajas del Diseño Modular

 Depuración de errores más sencilla: los módulos se pueden

escribir y probar de manera independiente.
 Mayor facilidad de mantenimiento: cada módulo de
programa se puede estudiar independientemente.
 Reutilización de código: lo que se hace es localizar procesos
útiles y darles un nombre. Cuando se ejecutan se hace a
través de su nombre sin tener que preocuparse de detalles
internos.
 Nuevas posibilidades: recursión.
 Procedimientos y Funciones

◦ La mayoría de los lenguajes permiten dos implementaciones para

subprogramas.

 FUNCIONES
 PROCEDIMIENTOS

◦ En C++, no hay procedimientos. Para emular su uso, se utilizan

funciones que utilizan como valor de retorno el tipo void.
◦ Pueden o no devolver valores.
◦ Ejecuta un proceso específico.
◦ Forma de Invocar un procedimiento:
 Nombre_procedimiento()
 Definición de Procedimiento

Se pueden declarar en el mismo fichero en el que está main()

o en otro fichero diferente para poder ser llamados por varios
programas.
Sintaxis de la de la definición
void NombreDelProcedimiento(<parámetros>)
{
<Cuerpo de la acción>
}
Objetivo: dar nombre al procedimiento, definir la acción que
va a realizar y declarar el conjunto de valores que va a
intercambiar con el programa.
Definición de Procedimiento
 Llamada a un Procedimiento

void NombreProc1(<parámetros def>)

{
<instrucciones para accion1>;
}
void NombreProc2(<parámetros def>)
{
<instrucciones para accion2>;
}

int main()
{
<instrucciones>;
NombreProc1(<parámetros llamada>);
NombreProc2(<parámetros llamada>);
<instrucciones>;
return 0;
}
 Llamada a un Procedimiento o Función

Principal Procedimiento/función

Llamada procedimiento

Procedimiento/función

Llamada procedimiento
Llamada procedimiento

Llamada procedimiento
Procedimiento/función

Llamada procedimiento
Llamada a un Procedimiento o Función
 Definición de una Función

 Una función permite agrupar un conjunto de instrucciones en

un bloque que realizará una tarea elemental.
 Para que una función se ejecute, es necesario que otra función
la llame.
 Función invocadora / invocada.

Transferencia del flujo del programa

Transferencia de
F. invocadora datos (opcional) F. invocada

Transferencia del flujo del programa

Definición de una Función
Estructura de una Función
 Ejemplo de Función

#include <stdio.h>

int cuadrado(int x){

int r;
r=x*x;
return r;
}

main(){
int i,resultado;
for (i=0;i<10;i++){
resultado = cuadrado (i);
printf("Cuadrado de %d:\t%d\n",i,resultado);
}
return 0;
}
 Definición de una Función

 Las funciones:
◦ Se declaran
◦ Se definen
◦ Se utilizan... en expresiones, en cálculos, en llamadas a otras
funciones.

◦ Una llamada a una función representa un dato (el valor

devuelto por ella), que tiene un tipo determinado.
 Definición de una Función

Sintaxis de la definición
<Tipo resultado> NombreFunción(<lista
parámetros>)
{
<Cuerpo de la función>
}

Objetivo
Dar nombre a la función, calcular el valor que va a devolver y declarar el
conjunto de valores que necesita que le pase el programa.
 Funciones

 Una función devuelve al programa en el que se la ha llamado un único

valor asociado a su nombre, en <Tipo resultado> se indica el
tipo al que pertenece.
 Los parámetros incluidos en <lista parámetros> son siempre
parámetros solo de entrada. Sirven para pasar desde el programa el
conjunto de valores necesarios para hacer el cálculo. Su sintaxis es:
<Tipo> const NombreParámetro
 En <cuerpo función> se incluye el conjunto de instrucciones
necesarias para llevar a cabo el cálculo del valor devuelto por la
función. El valor se devuelve al programa a través de la instrucción:
return valor;
Una función debe siempre incluir al menos una instrucción
return.
 Consideraciones sobre su Uso

 La función DEBE asignar un valor a su nombre, esta asociación se

realiza a través de la instrucción return.
◦ Puede haber más de un return dentro del cuerpo si se desean
devolver valores distintos en función de condiciones.
◦ Al llegar a return se suspende automáticamente la ejecución.
 Los identificadores declarados dentro de la función son locales con
respecto a ella.
 Las funciones siempre utilizarán parámetros por sólo de entrada. Su
propósito es el de devolver un único valor a través de su nombre.
 Lasfunciones se llaman desde el programa que las utiliza y en ese
momento se ejecuta su código asociado.
 Ejemplo de Llamada a Función

Ejemplo: Función Potencia.

//Llamada a la función
int main()
{
double base;
int exponente;
cout << “Introduzca la base: ”;
cin >> base;
cout << “Introduzca el exponente: ”;
cin >> exponente;
cout << “El valor de la potencia es: “ <<
potencia(base, exponente);
}
 Ejemplo de Declaración de Función

Ejemplo: Función Potencia.

//Declaración de la función
double potencia(double const x, int const
n)
{
double pot = 1;
for (int i = 0; i < n; i++)
pot = pot * x;
return pot;
}
 Parámetros de una Función

 Algunas funciones (o procedimiento) requieren de algunos

parámetros para poder efectuar una serie de instrucciones.

 Un parámetro es un valor que es ‘pasado’ a una función para

poder ser utilizado en la generación de resultados.

 Estos parámetros se clasifican en parámetros formales y

parámetros actuales.
 Parámetros Actuales/Reales y Parámetros Formales

 Son variables locales conocidas como parámetros formales y se

utilizan como un medio para entregarle información a la
función.
 Los parámetros formales reciben sus valores iniciales desde los
parámetros reales, es decir, desde los valores que se les pasan a
traveś de la llamada. Ejemplo:

Parámetro real (llamada)

main( ){
Parámetro formal (declaración)
imprimeEntero(5);
}
void imprimeEntero(int x){
printf(“%d\n”, x);/* x vale 5 */
}
 Parámetros Actuales y Parámetros Formales

 Los parámetros de la definición de la función o

procedimiento, son llamados parámetros formales, o
comúnmente parámetros.

 Los parámetros de la invocación de la función o

procedimiento son llamados parámetros actuales, o
comúnmente argumentos.

 Los parámetros formales y actuales pueden tener nombres

distintos, en la definición de la función es más generalizada
que la invocación. En la invocación es posible pasar como
argumentos valores específicos.
 Parámetros Actuales y Parámetros Formales

 Número de parámetros: Debe de ser el mismo número

de parámetros como de argumentos.

 Tipo de parámetro: el tipo de valor (o variable) que se

pasa como argumento en la invocación de una función,
deberá ser compatible con el tipo de parámetro en la
definición de la función.

 Orden en los parámetros: el orden los parámetros

deberá ser respetado en la invocación de acuerdo a la
definición de la función o procedimiento.
 Paso de Parámetros por Valor y por Referencia

Objetivo: realizar el intercambio de información entre los

bloques en los dos sentidos.
Dos tipos: La declaración
de parámetros
De entrada o por valor: en la cabecera
Tipo const NombreDelParámetro del
procedimiento
De entrada / salida o por variable: sirve como
declaración
Tipo &NombreDelParámetro local de las
variables
 Paso de Parámetros por Valor y por Referencia

 Por valor: copia el valor de un argumento de la llamada

en el parámetro formal de la función. Por lo tanto, los
cambios en los parámetros de la función no afectan a
las variables que se usan en la llamada.

 Por referencia: se copia la dirección del argumento en

el parámetro. Los cambios hechos a los parámetros
afectan a las variables usadas en la llamada a la
función.
 Paso de Parámetros por Valor

int sumar (int a, int b)

Memoria
{ int rdo;
rdo
a rdo=a+b;
2 5 return rdo;
b 3 }
....
printf (“El rdo es: %d“, sumar(2,3));
 Paso de Parámetros por Valor

Algoritmo Sumatoria
entero función suma (entero s)
Inicio
Leer numero1
Entero S
Leer numero2
S0
S  numero1 + numero2
Presentar suma(s)
Devolver S
Presentar s
finfunc
fin

¿Qué valor se presenta en la

numero1  5
llamada a la función?
numero2  8
¿Cuál es el valor de S?
 Paso de Parámetros por Valor

Al llamar a un subprograma, se transfiere el control de ejecución a ese

subprograma.
◦ Pasos:
1. Se declaran las variables de los argumentos formales.
2. Se copia el valor de los argumentos actuales en las
variables de los argumentos formales.
Esta copia se hace por orden: NO POR NOMBRE.
Los argumentos actuales y formales SON VARIABLES
DISTINTAS. Si el argumento formal se modifica en
la función, el actual NO se ve afectado por el
cambio.
3. Se declaran las variables locales a la función.
4. Se ejecuta el código de la función.
5. Al terminar la función, las variables locales son
destruidas.
 Paso de Parámetros por Valor

int sucesor(int x){

x++;
return x;
}

//Cuerpo principal del programa

void main() {
int y = 10;
y = sucesor (y);
}

main () sucesor (int x)

y 10 x 10

Copia
 Paso de Parámetros por Valor

double valor_abs( double x )

{
double abs;
if (x < 0.0)
abs = -x;
else
abs = x;
return ( abs );
} // archivo prueba.cpp
#include <stdio.h>
double valor_abs(double);
// declaración

void main (void)

{
double z, y;
y = -30.8;
z = valor_abs(y) + y*y;
// llamada en una expresión
}
 Paso de Parámetros por Valor
int main()
{
short int tipoConv;
float Cantidad;
cout << “Este programa convierte de córdobas a dólares y
viceversa”;
do{
cout << “Introduzca tipo de conversión\n”
<<”1. Córdobas a Dólares\n”
<<”2. Dólares a Córdobas\n”;
cin >> tipoConv;
}while (!(tipoConv >= 1)&&(tipoConv <= 2));
cout << “Introduzca cantidad\n”;
cin >> Cantidad;
ConvertirMoneda(tipoConv,Cantidad);
getchar();
return0;
}
 Paso de Parámetros por Valor

#include <iostream.h>
#include <vcl.h>
void ConvertirMoneda (short int const tipo, float const
cantidad)
{
float const Factor = 32.8;
if (tipo == 1)
cout << cantidad << “ córdobas equivalen a ”
<< cantidad/factor << “ dólares”;
else
cout << cantidad << “ dólares equivalen a ”
<< cantidad*factor << “ córdobas”;
}
 Paso de Parámetros por Referencia

 Permite modificar los argumentos actuales:

◦ Es otra forma de conseguir que una función devuelva
valores (aparte del return).

◦ De esta forma, una función puede devolver tantos valores

como se deseen.

◦ Se llama paso de argumentos por referencia, a una técnica

que permite a una función modificar variables utilizadas
como argumentos actuales.
 Paso de Parámetros por Referencia

Algoritmo suma
función suma (entero var s) entero
Inicio
Leer numero1
Entero S
Leer numero2
S0
S  numero1 + numero2
Presentar suma(s)
Devolver S
Presentar s
finfunc
fin

¿Qué valor se presenta en numero1  5

la llamada a la función? numero2  8

¿Cuál es el valor de S?
 Paso de Parámetros por Referencia

#include <iostream.h>

//Intercambio de valores entre dos variables.

//Uso de variables tipo referencia (int &x)
//que comparten la misma posición de memoria.

void intercambiar (int &x, int &y) {

int aux = x;
x = y;
y = aux;
}

main() {
int x=1, y = 2, z = 3;
intercambiar (x, y);
intercambiar (y, z);
cout << endl << "Valores de x: " << x << " y: " <<
y << " z: " << z;
} ¿Resultado?
 Uso de Procedimientos

Se usarán procedimientos cuando:

 No se devuelve ningún valor.

 Se devuelve más de un valor (estructura).
 Se realiza una operación de E/S, además de devolver un
valor (estructura).
 Ventajas de las Funciones

Usar funciones en lugar de procedimientos en los demás

casos puede tener ventajas:

 Al dar nombre al cálculo de un valor, se puede hacer

referencia a él con mayor facilidad: se puede usar la llamada
dentro de expresiones.
 Las llamadas a funciones se pueden anidar dentro de otras
funciones y el valor devuelto servir como parámetro de
entrada a la función externa. Una llamada a un
procedimiento siempre es una instrucción.
 Similitudes entre Procedimientos y Funciones

 Los dos se definen en la sección de subprogramas de la

parte de declaraciones. Se componen de las mismas
secciones: cabecera, declaraciones, instrucciones.
 Son unidades de programa independientes. Los objetos
declarados dentro de ellos son locales (sólo accesibles
dentro del subprograma).
 Al llamar a ambos, el número de parámetro reales tiene que
coincidir con el de formales y ser del mismo tipo.
 Diferencias entre Procedimientos y Funciones

 Losprocedimientos se invocan mediante una instrucción de

llamada. Las funciones usando su nombre dentro de una
expresión.
 Sedebe asociar un valor y un tipo al nombre de la función
que especifique el resultado. No se asocia ningún valor a
nombres de procedimientos.
 Lasfunciones devuelven un único valor. Un procedimiento
puede devolver uno, varios o ningún valor.
 En procedimientos, los valores se devuelven a través de
parámetros por variable. Para las funciones, se asigna el
valor al nombre de la función.
 ¿Dónde Definir los Subprogramas en C++?

 Antes de la función main()

◦ OJO: en C++ cualquier entidad debe ser declarada antes de
ser utilizada.

 Después de la función main ().

◦ Antes de main() deben declararse sus prototipos. El código
puede encontrarse después de la llamada.

 En una unidad diferente a la de main().

◦ El .cpp que contiene el código de la función y el de main()
deben estar en el mismo proyecto.
◦ Los prototipos también se pueden declarar en un fichero .h
independiente y hacer el #include “fichero.h” donde se
encuentran antes de la llamada.
 ¿Dónde Definir los Procedimientos en C++?. Antes.

void NombreProc1(<parámetros def>)

{
<instrucciones para acción1>;
}
void NombreProc2(<parámetros def>)
{
<instrucciones para acción2>;
}
int main()
{
<instrucciones>;
NombreProc1(<parámetros llamada>);
NombreProc2(<parámetros llamada>);
<instrucciones>;
return 0;
}
 ¿Dónde Definir las Funciones en C++?. Después.

tipo NombreFunción1(<parámetros def>);

tipo NombreFunción2(<parámetros def>);

int main()
{
<instrucciones>;
x = NombreFunción1(<parámetros llamada>);
y = x + NombreFunción2(<parámetros llamada>);
<instrucciones>;
return 0;
}

tipo NombreFunción1(<parámetros def>)

{
<instrucciones Función1>;
}
tipo NombreFunción2(<parámetros def>)
{
<instrucciones Función2>;
}
 ¿Dónde Definir las Funciones en C++?. En Ficheros Diferentes.
FicMain.cpp

#include “prototipos.h”

int main()
{
<instrucciones>;
x = NombreFunción1(<parámetros llamada>);
y = x + NombreFunción2(<parámetros
llamada>);
<instrucciones>;
return 0;
}
Ficfunción1.cpp prototipos.h
<TipoFunción1> NombreFunción1
(<parámetros llamada>);
<TipoFunción1> NombreFunción1
(<parámetros llamada>)
{
<instrucciones>;
return <valorTipoFunción1>;
}
 Ambito de las Variables

 Variables Locales:
◦ Se declaran dentro de la función y sólo están
disponibles durante su ejecución.
◦ Se crean cuando se entra en ejecución una
función y se destruyen cuando se termina.

 Variables globales:
◦ Se declaran fuera de las funciones. Pueden ser
utilizadas por todas las funciones.
◦ Existen durante toda la vida del programa.
 Ambito Local de una Variable

Procedimiento/función Procedimiento/función
principal
Entero numero
Llamada procedimiento
numero = 25
Llamada procedimiento
Presentar numero

Procedimiento/función

Llamada procedimiento

Procedimiento/función

Llamada procedimiento Numero = 25

Ambito Global de una Variable
 Ambito de las Variables

Var. Global
#include <iostream.h>

int x = 2;
x

int cuadrado (int z) { int cuadrado

int q;
z, q z, q, x
q = z * z;
return q; Var. Locales a
} cuadrado
x
void main() { main
int p;

p = 10; p p, x
x = cuadrado (p);
cout << x;
} Var. Locales a main
 Ambito de las Variables

 Conflictos de nombres:
◦ Un mismo identificador de variable puede utilizarse en
distintos lugares del programa para declarar variables
distintas.

◦ En todos los casos, se considera que un nombre siempre

identifica a la variable más local que tenga ese nombre.
 Ambito de las Variables

int sucesor(int x){

x++;
return x; Declar. inicial. de x
}
//Cuerpo principal del programa main ()
void main() {
int x = 10; x 10
x = sucesor (x);
}
main () sucesor (int x)

x 10 x 10

main () sucesor (int x)

x 10 x 11

main ()
x 11
 Ambito de las Variables

#include <iostream.h>

int x = 100, y = 200;

int por10 (int x) {
int resultado, y = 10;

resultado = x * y;
return resultado;
}

void main() {
int resultado, x;

x = por10(y); ¿resultado?
resultado = por10 (x);
cout << resultado;
}
int M = 230; int i, j; Ambito de las Variables
int A ( int i, int incrementa)
{ VARIABLES QUE SE VEN DESDE CADA BLOQUE
int r=1; int s=0; Bloque Variable Descripción
Ppal M Variable Global
int B ( int g, int despedida)
i,j Variables globales
{ A Subprograma declarado en Ppal
int m = 1; int n = 0; main Subprograma declarado en Ppal
if (despedida) main z Variable local a main
M Variable Global
return (n); i,j Variables globales
else A Subprograma declarado en Ppal
return (m); main Subprograma declarado en Ppal
}; A i, incrementa Parámetros de A son locales a A
r, s Variables locales a A
if (incrementa && r || s) B Subprograma local a A
return B ( i, incrementa); j Variable global declarada en ppal
else B Subprograma declarado en A
M Variable global
return B ( M, !incrementa);
B g, despedida Parámetros locales a B
} m ,n Variables locales a B
int main () r, s Variable declaradas en A globales en B
{ i, incrementa Parámetros de A globales en B
j Variable global declara en Main
int z; j = 1;i = 230 +  j; z = i; A Subprograma declarado en ppal
printf ( "%d\n", A( z, 1)); B Subprograma declarado en A
} M Variable global declara en ppal
 Paso de Argumentos a Funciones

#include <stdio.h>

void modificar (int a){

a=a*3;
printf (“\nValor desde la función: %d\n”, a);
}
main(){
int a=2;
printf (“\nValor antes de llamar a la función: %d\n”, a);
modificar (a);
printf (“\nValor después de llamar a la función: %d\n”, a);
}

Valor antes de llamar a la función: 2

Valor desde la función: 6
Valor después de llamar a la función: 2
 Paso de Argumentos a Funciones

#include <stdio.h>

float cent_to_rad (float angulo)

{
float nuevo_angulo;
nuevo_angulo = angulo*3.1416/200;
return (nuevo_angulo);
}

main(){
float a;
printf (“\nValor del ángulo a convertir:”);
scanf (“%f”, &a);
a = cent_to_rad (a);
printf (“\nValor del ángulo en radianes: %f\n”, a);
}
Ejemplo: Paso de Parámetros a una Función
int xvalor (int a, int b)
{
a=b; return a;
};
void xref1(int *a, int *b)
{
*a=*b;
}; Pasada de parámetros por
int main() valor. Las variables
{
actuales no se modifican.
int a, b, c;
a = 1; b = 2;
c = xvalor( a, b);
printf("a=%d,b=%d, c=%d\n", a, b, c);
xref1(&a, &b);
printf("a=%d,b=%d\n", a, b);
Pasada de parámetros por
system("PAUSE");
 
referencia. Significa que se
return 0;
modifican las variables
} actuales.
 Paso de Parámetros por Referencia

int main() const int n=2,m=5;

{ void llena_matriz( int matriz[][m], int n, int m)
{
int mat[n][m];
int i, j;
llena_matriz(mat, 2, 5);
for (i=0;i<n;i++)
imprime_matriz(mat, n, m); for (j=0; j<m;j++)
system("PAUSE"); matriz[i][j]=i * m + j;
return 0; };
} void imprime_matriz( int matriz[][m], int n, int m)
{
int i, j;
for (i=0;i<n;i++)
{
for (j=0;j<m;j++)
printf("%d ",matriz[i][j]);
printf("\n");
};
};
 
 Prototipo de Funciones

 Uso:
◦ Identificar el tipo de retorno de la función.
◦ Especificar el tipo y el número de argumentos que
utiliza la función.

 El prototipo debe aparecer antes de que se haga

cualquier llamada a la función.

 No es necesario incluir los nombres reales de los

parámetros.
 Prototipo de Funciones

Ejemplo.

 
 Prototipo de Funciones

#include <stdio.h>

int cuadrado(int x); /*Prototipo*/

main(){
int i,resultado;
for (i=0;i<10;i++){
resultado = cuadrado (i);
printf("El cuadrado de %d es %d\n",i,resultado);
}
return 0;
}
int cuadrado(int x){
int a;
a=x*x;
return a;
}
 Prototipo de Funciones

#include <stdio.h>
void intercambio(int *, int *) /*Prototipo*/
main(){
int a=5,b=3;
printf("a=%d b=%d\n",a,b);
intercambio (&a,&b);
printf("a=%d b=%d\n",a,b);

return 0;
}
void intercambio(int *x, int *y){
int temp;
temp=*x;
*x=*y;
*y=temp;
}
 Contadores, Acumuladores e Interruptores

 Un contador es una variable cuyo valor se incrementa

o decrementa en una cantidad constante en cada
iteración.

 Un Acumulador es una variable cuya misión es

almacenar cantidades distintas resultantes de sumas
sucesivas.

 Un interruptor (conmutador, bandera, flag) es una

variable que puede tomar diversos valores durante la
ejecución de un programa y que permite comunicar
información desde una parte a otra del mismo (true o
false).
 Ejercicios Propuestos (Utilizar Funciones)

Area de un círculo: A   * R2

Area del triángulo:

det(M) = x1·y2·½ + x2·y3·½ + x3·y1·½ - y1·x2·½ - y2·x3·½ - y3·x1·½

 Ejercicios Propuestos

9*º C
 Celsius a Fahrenheit:: ºF   32
5
N 1

 A[i]
 Valor promedio de una onda: P i 0
N

 Evalúa f(4): f ( x)  x 4  4 x 3  2 x  4
 Investigación Documental #2

◦ Para la próxima sesión (Debate) presentar una investigación

sobre: definición y características de los procedimientos,
funciones y recursividad (ejemplos). Además, agregar la
clasificación de las funciones (predefinidas, ordinales,
definidas por el usuario y estándar).

◦ No más de 5 hojas con portada.

◦ Fecha de entrega: Domingo 7/4/2019