ALP Unidad 4: Programación modular

Algoritmos y Lógica de Programación Carrera de Software
Ph.D. Franklin Parrales 1
12/03/2022
Programación modular
Unidad 4
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Algoritmos y Lógica de Programación

12/03/2022
Objetivo general de la Unidad 4
Implementar funciones propias del programador mediante
la aplicación de la técnica de la programación modular
para la resolución de problemas en el desarrollo de
software con calidad.

12/03/2022
Contenido
• Diseño descendente
• Módulos, cohesión – Modularidad: Funciones propias
del lenguaje de programación.
• Sub-programas, Funciones y Procedimientos.
Declaración y definición.
• Recursividad
• Paso de parámetros por valor y referencia.
• Construcción de Librerías (Bibliotecas)

12/03/2022
Diseño descendente (top-down)
• Permite abordar problemas complejos
• Consiste en descomponer el problema grande
en varios pequeños
– Módulos independientes
– Procedimientos, funciones y bloques de código
Modularidad
Función
F1
Función
F2
Procedimiento
P1
Programa
Principal

12/03/2022
Contenido
• Recursividad

12/03/2022
Dividir y Conquistar (1)
• Debido a la complejidad de los grandes
problemas y las limitaciones de la mente
humana estos no se pueden atacar como
una unidad monolítica
– Aplicar dividir y conquistar
– Dividir en piezas que pueden ser “conquistadas”
por separado. Sino se hizo una división poco
inteligente
• Dividir en piezas con esta propiedad es una
tarea compleja para el diseño de software

12/03/2022
Dividir y Conquistar (2)
• Las piezas
– Están relacionadas. Juntas forman el sistema
– Entonces, existe comunicación y cooperación
entre las mismas
– Esto agrega complejidad, que surge de la
propia partición
– Cuando el costo de particionar sumado la
complejidad agregada supera los ahorros
logrados por particionar se debe detener el
proceso

12/03/2022
Modularización
• Módulo: un componente bien definido de un
sistema de software que provee recursos y
servicios
– Están bien definidos:
• Recursos y Servicios
• La forma de suministrarlos (Interfaces)
– Un módulo puede ser un programa o varios, una
subrutina o varias
• Principio de Separación de Intereses
– cada módulo se ocupa de aspectos específicos
(cohesión)

12/03/2022
Modularizar
• Dividir sucesivamente, obteniendo niveles
– Se formará una jerarquía de módulos
– Los de mas bajo nivel
• Resuelven problemas más pequeños y
• Contienen mas detalle
• Hasta que los módulos de nivel inferior
– Sean sumamente simples
– Y solo contengan funciones y procedimientos
– Que resuelven problemas independientes y
pequeños

12/03/2022
Cuando modularizar
• Si un conjunto de sentencias realiza una tarea
– Recurrente, repetitiva, identificable
• Debe ser un módulo
• Sin embargo,
– Una tarea no necesita ser recurrente para hacerla un
módulo
Modularidad
Función
F1
Función
F2
Procedimiento
P1
Programa
Principal

12/03/2022
Cohesión
• Se focaliza en conocer el por qué los
elementos de un módulo están juntos en
ese módulo
• El objetivo es tener en un mismo módulo
elementos que están fuertemente
vinculados
– Entonces, módulos más fáciles de entender
– y más fáciles de modificar

12/03/2022
Descomposición
Deben hacerse módulos, pero con cuidado para permanecer en
la cercanía de M. Debe evitarse hacer pocos o muchos
módulos.
Región de
costo mínimo
M
Costo
del
esfuerzo
Costo de integración
Costo total del software
Costo por módulo
Número de módulos

12/03/2022
Funciones propias del lenguaje de programación
# Función Tipo Biblioteca Sintaxis Descripción Ejemplo
1 abs(i) int stdlib.h int abs(int i);
Devuelve el valor
absoluto de i
x = abs(-7) // x es 7
2 acos(d) double math.h double acos(double d);
Devuelve el arco
coseno de d
angulo = acos(0.5); // angulo
devuelto es phi/3
3 asin(d) double math.h double asin(double d);
Devuelve el arco
seno de d
angulo = asin(0.707); //
aproximadamente phi/4
4 atan(d) double math.h
double atan(double d);
long double tanl(long double
d);
Devuelve la arco
tangente de d.
Calcula el arco
tangente del
argumento x.
Requiere el
llamado de la
biblioteca
complex.h
angulo atan(1.0); // angulo es
phi/4
5 atan(d1, d2) double math.h
double atan(double d1, double
d2);
Devuelve el arco
tangente de d1/d2
angulo = atan(y, x)
6 atof(s) Double stdlib.h
double atof(const char
*cadena)
Convierte la
cadena s a una
cantidad de doble
precisión. Requiere
el llamdo de la
biblioteca math.h
double x;
char *cad_dbl = "200.85"; ...
x=atof(cad_dbl); // convierte
la cadena "200.85" a valor
real

12/03/2022
7 atoi(s) int stdlib.h
int atoi(const char
*cadena)
Convierte la cadena s
a un entero.
La cadena debe tener
el siguiente formato:
[espacio en
blanco][signo][ddd]
(siendo obligatorio los
digitos decimales).
int i;
char *cad_ent="123";
...
i=atoi(cad_ent); //convierte
la cadena "123" al entero
123
8 atol(s) long stdlib.h
long atol(const char
*cadena);
Convierte la cadena s
a un entero largo.
La cadena debe tener
el siguiente formato:
[espacio en
blanco][signo][ddd]
(siendo obligatorio los
digitos decimales).
long int i;
char cad_ent="9876543";
...
i=atol(cad_ent); //convierte
la cadena "9876543" al
entero largo
9 calloc(n, s)
void(punt
ero)
malloc.h
y stdlib.h
o bien
alloc.h y
stdlib.h
void *calloc(size_t n,
size_t s);
Reserva memoria
para una formación de
n elementos , cada
uno de s bytes.
Devuelve un puntero
al principio del espacio
reservado.
Si no existente
bastante espacio para
el nuevo bloque o bien
n o s es 0, calloc
devuelve nulo.
long *buffer
buffer=(long *) calloc(40,
sizeof(long));

12/03/2022
10 ceil(d) double math.h double ceil(double d);
Devuelve un
valor redondeado
por exceso al
siguiente entero
mayor
redondeo=ceil(5.1);
//redondeo es 6
11 cos(d) double math.h
double cos(double d);
complex cos(complex d);
Devuelve el
coseno de d
coseno_x=cos(1.6543)
12 cosh(d) double math.h
double cos(double d);
complex cos(complex d);
Devuelve el
coseno
hiperbólico de d
d=1.00;
printf("d=%f.nn,d);
13
difftime(11,
12)
double time.h
double difftime(time_t hora2,
time_t hora1)
Devuelve la
diferencia de
tiempo 11(hora2)
- 12(hora1) ,
donde 11 y 12
representan el
tiempo
transcurrido
despues de un
tiempo base (ver
función time)
time_t inicio, fin;
clrscrl();
inicio=time(NULL);
delay(5000)
fin=time(NULL)
print("Diferencia en
segundos: %fn",
difftime(inicio,fin));

12/03/2022
14 exit(u) void stdlib.h void exit(int estado)
Cierra todos los
archivos y buffers y
termina el programa.
El valor de u es
asignado por la
funcion para indicar el
estado de
terminación.
exit(0);
15 exp(d) double math.h
double exp(double d);
complex exp(complex
d)
Eleve e a la potencia
d (e=2,7182818... es
la base del sistema
de logaritmos
naturales
(neperianos))
d=100.00;
y=exp(d);
printf("El exponencial de
x=%f.nn",y);
16 fabs(d) double math.h double fabs(double d);
Devuelve el valor
absoluto de d
y=fabs(-7.25); // y vale 7.25
17 fclose(f) int stdio.h int fclose(FILE *f);
Cierra el archivo f.
Devuelve el valor 0 si
el archivo se ha
cerrado con exito.
int fclose(FILE "archivo");
18 feof(f) int stdio.h int feof(FILE *f);
Determina si se ha
encontrado un fin de
archivo. si es asi,
devuelve un valor
distinto de cero, en
otro caso devuelve 0
feof(fichen);

12/03/2022
19 fgetc(f) int stdio.h int fgetc(FILE f);
Lee un caracter
del archivo f
c+fgetc(fp)
20 fegts(s, i, f)
char(pun
tero)
stdio.h
char *fgets(char s, int s,
FILE *f);
Lee una cadena
s, con i
caracteres, del
archivo f
fgets(caddemo, 80, fp);
22 fmod(d1, d2) double math.h
double fmod(double d1,
double d2);
Devuelve el resto
de d1/d2 (con el
mismo signo que
d1)
resto=fmod(5.0,2.0); // resto
igual a 1.0
23 fprintf(f, ...) int stdio.h
int fprintf(FILE *f, const char
*formato [,arg,...]);
Escribe datos en
el archivo f (el
resto de los
argumentos
fprintf(f1, "El resultado es
%fn",result);
24 fputc(c, f) int stdio.h int fputc(int c, FILE *f);
Escribe un
caracter en el
archivo f
fputc(*(p++), stdout);
25 fputs(s, f) int stdio.h
int fputs(const char *cad,
FILE *f)
Escribe una
cadena de
caracteres en el
archivo f
fputs("esto es una prueba",
f1);
26
fread(s, i1,
i2, f)
int stdio.h
size_t fread(void *b, size_t
t, size_t n, FILE *f);
Lee i2 elementos,
cada uno de
tamano i1 bytes,
desde el archivo f
hasta la cadena s
fread(buf, strlen(msg)+1, 1,
flujo);

12/03/2022
27 fopen(s1, s2)
file(p
unter
o)
stdio.h
FILE
*fopen(const
char *s1,
const char
*s2)
Abre un archivo llamado s1, del tipo s2. Devuelve
un puntero al archivo. *
if
((corriente2=f
open("datos","
W+"))==NULL
printf("El
archivo...no
se ha abierto
n");
Modo Acción
"r" Abre para lectura
"w"
Abre un archivo vacío para
escritura
"a"
Abre para escritura al final
del archivo
"r+" Abre para lectura/escritura
"w+"
Abre un archivo vacio para
lectura/escritura
"a+" Abre para lectura y anadir
"rb"
Abre un archivo binario
para lectura.
"wb"
para escritura
"ab"
para anadir
"rb+"
para lectura/escritura.
"wb+"
para lectura/escritura
"ab+"
Abre o crea un archivo
binario para
lectura/escritura

12/03/2022
28 free(p) void
malloc.h
o stdlib.h
void free(void
*dir_memoria);
Libera un bloque de memoria
reservada cuyo principio esta
indicado por p.
char *cad;
// asignar memoria a la
cadena
cad=(char *)malloc(50);
...
free(cad); // liberar
memoria
29 fscanf(f, ...) int math.h
int fscanf(FILE *f,
const char *formato,
[, direccion,... ]);
Lee datos del archivo f ( el resto
de los argumentos
fscanf(flujo, %s%f, cad,
&f);
30 fseek(f, l, i) int stdio.h
int fseek(FILE *f, long
desplaza, int origen);
Mueve el puntero al archivo f una
distancia de 1 bytes desde la
posición i (i puede representar el
principio del archivo, la posición
actual del puntero o el fin del
archivo.
Notas
fseek(f1,OL,SEEK_SET);
// ir al principio
Origen Significado
SEEK_SET
Principio de
archivo
SEEK_CUR
Posicion
actual
puntero
SEEK_END
Final del
archivo

12/03/2022
31 ftell(f) long int stdio.h
long int ftell(FILE
*f);
Devuelve la posicion
actual del puntero
dentro del archivo f
ftell(fichen)
32
fwrite(s, i1,
i2, f)
int stdio.h
size_t fwrite(const
void *p, size_t i1,
size_t i2, FILE *f);
Escribe i2 elementos,
cada uno de tamano 1
bytes, desde la cadena
s hasta el archivo f
num=fwrite(lista,sizeof(char),25,
flujo);
33 getc(f) int stdio.h int getc(FILE *f);
Lee un caracter del
archivo f
while(c=getc(fx) !=EOF {
print ("%c",c);
}
34 getchar( ) int stdio.h int getchar(void);
Lee un caracter desde
el dispostivo de entrada
estandar
int c;
while((*c=getchar()) != 'n')
print ("%c",c);
35 gets(s)
char(pun
tero)
stdio.h
char *gets(char
*cad);
Lee una cadena de
caracteres desde el
dispositivo de entrada
estandar
gets(nombre);
36 isalnum(c) int ctype.h int isalnum(int c);
Determina si el
argumento es
alfanumerico. Devuelve
un valor disitinto de
cero si es cierto; en
otro caso devuelve 0
carac=getch();
if (isalnum(carac))
print("%c letra|digito n",carac);
else
printf("%c no letra|digito n",
carac);

12/03/2022
37 isalpha(c) int ctype.h
int isalpha(int
c);
Determina si el argumento
es alfabetico. Devuelve un
valor distinto de cero si es
cierto; en otro caso
devuelve 0.
int c;
if (isalpha(c)) printf("%c es
letran",c);
38 isascii(c) int ctype.h
int isascii(int
c);
es un caracter ASCII.
Devuelve un valor disitinto
de cero si es cierto; en otro
caso devuelve 0
int c;
if (isascii(c)) printf('%c es un
asciin",c)
39 iscntrl(c) int ctype.h
int isacntrl(int
c);
es un caracter ASCII de
control. Devuelve un valor
distinto de cero si es cierto;
en otro caso devuelve 0
if(iscntrl(c)) printf"%c es un
caracter de controln",c);
40 isdigit(c) int ctype.h
int isdigit(int
c);
Determina si el numero es
un digito decimal. Devuelve
un valor disitinto de cero si
es cierto; en otro caso
devuelve 0
if(isdigit(c)) printf"%c es un
digiton",c);
41 isgraph(c) int ctype.h
int isgraph(int
c);
es un caracter ASCII grafico
(hex 0x21 -0x7e; octal 041 -
176). Devuelve un valor
distinto de cero si es cierto;
en otro caso devuelve 0
if(isgraph(c)) printf"%c es un
caracter imprimible(no
espacio)n",c);

12/03/2022
42 islower(c) int ctype.h
int islower(int
c);
es ua minuscula. Devuelve
un valor distinto de cero si
devuelve 0
if(islower(c)) printf"%c es una
letra minusculan",c);
43 isodigit(c) int ctype.h
int isodigit(int
c);
es un digito octal. Devuelve
un valor distinto de cero si
devuelve 0
if(isodigit(c)) printf"%c es un
digito octaln",c);
44 isprint(c) int ctype.h
int isprintint
c);
Determina si el el
argumento es un caracter
ASCII imprimible (hex 0x20
-0x7e; octal 040 -176).
Devuelve un valor distinto
caso devuelve 0
if(isprint(c)) printf("n"c
imprimiblen",c);
45 ispunct(c) int ctype.h
int ispunct(int
c);
es un caracter de
puntuacion. Devuelve un
valor distinto de cero si es
cierto; en otro caso
devuelve 0
if(ispunct(c)) printf"%c es un
caracter de puntuacionn",c);
46 isspace(c) int ctype.h
int isspace(int
c);
es un espacio en blanco.
caso devuelve 0
if(isspace(c)) printf"%c es un
espacion",c);

12/03/2022
47 isupper(c) int ctype.h
int isupper(int
c);
es una mayuscula.
caso devuelve 0
if(isupper(c)) printf"%c es una
mayusculan",c);
48 isxdigit(c) int ctype.h
int isxdigit(int
c);
es un digito hexadecimal.
caso devuelve 0
ifisxdigit(c)) print"%c es un digito
hexadecimaln",c)
49 labs(l) long int math.h
long int
labs(long int
l);
Devuelve el calor absoluto
de 1
long lx=-51654,ly;
ly=labs(lx);
50 log(d) double math.h
double
log(double d);
Devuelve el logaritmo
natural de d
hdouble x,y;
x=10;
y=log(x);
51 log10(d) double math.h
double
log10(double
d);
Devuelve el logaritmno (en
base 10) de d
hdouble x,y;
x=10;
y=log10(x);
52 malloc(u)
void(pun
tero)
stdlib.h
void
*malloc(size_t
u);
Reserva u bytes de
memoria. devuelve un
puntero al principio del
espacio reservado
cadena=malloc(MAX_CHR);
53 pow(d1, d2) double math.h
double
pow(double
d1, double
d2);
Devuelve d1 elevado a la
potencia d2
double x=2.0, y=4.0, z;
z=pow(x,y); //z sera 1.60

12/03/2022
54 printf(...) int stdio.h
int printf(const
char
*formato[,argu
mento,...]);
Escribe datos en dispositivo de
salida estándar.
print("producto %d y %d es
%dn",x,y,x*y);
55 putc(c, f) int stdio.h
int putc(int c,
FILE *f);
Escribe un caracter en el
archivo f
putc('*',demo);
56 putchar(c) int stdio.h
int putchar(int
c);
Escribe un caracter en el
dispositivo de salida estandar
putchar('B');
57 puts(s) int stdio.h
int puts(const
char *cad)
Escribe una cadena de
caracteres en el dispositivo de
salida estandar
puts("Desea continuar (s/n);
58 rand( ) int stdlib.h int rand(void);
Devuelve un entero positivo
aleatorio
// visualizar 10 numeros
aleatoriosfor (i=0;i<10;i++)
printf("%6d",rand());
Código Formato
%c Caracter
%d Entero Decimal
%e
Real (double o
float), notacion
cientifica.
%f Coma flotante
%s
Cadena de
caracteres
%x
Hexadecimal sin
signo

12/03/2022
59 rewind(f) void stdio.h
void
rewind(FILE *f);
Mueve el puntero al principio del
archivo f
rewind(fx);
60 scanf(...) int stdio.h
int scanf(const
char *formato
{,direccion,...]);
Lee datos en dispositivo de
entrada estándar
scanf('%d %f %c %s, &i,
&fp, &c, s);
61 sin(d) double math.h
double
sin(double d);
Devuelve el seno de d
double x, y;
x=0.52;
printf('x =%f radianesn",x);
y=cos(x);
printf("el coseno de x
=%fn",y);
62 sinh(d) double math.h
double
sinh(double d);
Devuelve el seno hiperbolico de
d
y=sinh(x);
63 sqrt(d) double math.h
double
sqrt(double d);
Devuelve la raiz cuadrada de d
printf("%lf",sqrt(25.0); //se
visualiza 5
Codigo Formato
%c Caracter
%d Enetero Decimal
%x Hexadecimal
%i Entero Decimal
%f Numero Real
%o Octal
%p Puntero
%s Cadena

12/03/2022
64 srand(u) void stdlib.h
void
srand(unsigne
d u);
Inicializa el generador de
numeros aleatorios
srand(semilla);
65
strcmp(s1,
s2)
int string.h
int
strcmp(const
char*s1, const
char *s2);
Compara dos cadenas de
caracteres
lexicograficamente.
Devuelve un valor negativo
si s1 < s2; 0 si s1 y s2 son
identicas; y un valor positivo
si s1 > s2
i=strcmp("MNP", "mnp"); //
resultado < 0
i=strcmp("abc", "abc"); //
resultado = 0
i=strcmp("xy", "abc"); //
resultado > 0char
s1[80]="Mayo";
char s2[80]="Octubre";
int j;
j=strcmp(s1,s2);
66
strcmpi(s1,
s2)
int string.h
int
strcmpi(const
char*s1, const
char *s2);
Compara dos cadenas de
caracteres
lexicograficamente, sin
diferenciar mayusculas de
minusculas. Devuelve un
valor negativo si s1 < s2; 0
si s1 y s2 son identicas; y
un valor positivo si s1 > s2
v=strcmpi(s1,s2);
67
strcpy(s1,
s2)
char string.h
char
*strcpy(char
s1, const char
s2);
Copia la cadena de
caracteres s2 en la cadena
s1
char *s1="Pepe Luis";
char b[12];
strcpy(s2,s1);
cout <<s2<< 'n';

12/03/2022
68 strlen(s) int string.h
size_t
strlen(const
char *s);
Devuelve el numero de
caracteres de una cadena
longitud=strlen(nombre);
char s[81]="Cadena demo';
printf("La longitud de s es:
%dn" strlen(s));
69 strset(c, s)
char(pun
tero)
string.h
char
*strset(char
*cad, int c);
Pone todos los caracteres
de s a c (excluyendo el
caracter nulo del final 0)
char *cad="----";
strset (cad,'x'); // cad es ahora
xxxx
70 system(s) int string.h
system(comd)
;
Pasa la orden al sistema
operativo. Devuelve cero si
la orden se ejecuta
correctamente; en otro caso
devuelve un valor distinto
de cero, tipicamente -1.
system(dir);
71 tan(d) double math.h
double
tan(double d);
Devuelve la tangente de d y=tan(x);
72 tanh(d) double math.h
double
tanh(double
d);
Devuelve la tangente
hiperbolica de d
a=tanh(x);
73 time(p) long int time.h
time_t
time(time_t
*h);
Devuelve el numero de
segundos transcurridos
despues de un tiempo base
designado
time(&hora);
74 toascii int ctype.h
int toascii(int
c);
Convierte el valor del
argumento a ASCII
c=toascii(entero);
75 tolower int
ctype.h o
stdlib.h
int tolower(int
c);
Convierte una letra a
minuscula
c=tolower('s'); //c se convierte
en 's'
76 toupper int
ctype.h o
stdlib.h
int toupper(int
c);
Convierte una letra a
mayuscula
c=toupper('s'); //c se convierte
en 'S'

12/03/2022
Contenido
• Recursividad

12/03/2022
Estructura de los programas que hemos
visto hasta el momento
• Se tiene un solo archivo
fuente.
• Todo lo que hace el
programa se implementa
dentro de la función main.
#include <archivo_cabecera>
declaracion_variables_globales;
int main() {
declaracion_variables_locales;
instruccion_1;
instruccion_2;
. . .
instruccion_N;
return 0;
}

12/03/2022
Problemas de esta metodologia
#include <stdio.h>
int a[3],b[3],c[3];
int main() {
int i;
printf(" Ingrese el primer vector: ");
for(i=0;i<3;i++) {
scanf("%d",&a[i]);
}
printf(" vec1 = [%d %d %d]nn",a[0],a[1],a[2]);
printf(" Ingrese el segundo vector: ");
for(i=0;i<3;i++) {
scanf("%d",&b[i]);
}
printf(" vec2 = [%d %d %d]nn",b[0],b[1],b[2]);
for(i=0;i<3;i++) {
c[i]=a[i]+b[i];
}
printf(" vec3 = vec1 + vec2 = [%d %d %d]nn",c[0],c[1],c[2]);
return 0;
}
Repetición de código
Código
chorizudo

12/03/2022
Problemas de esta metodologia
• Programación repetida.
• A medida que el problema se hace mas
complejo el main tiende a crecer mucho y
hacerse mas difícil de entender.
• Dificultad para programar.
• Poca reutilización de código

12/03/2022
Ejemplo
...
!
7
!
5
!
3
)
(
7
5
3
+
−
+
−
=
x
x
x
x
x
sen
Realizar un programa que calcule el valor de la función
seno usando la serie equivalente para ello. Los valores
de entrada son x y el numero de términos.
A continuación se muestra la serie equivalente:

12/03/2022
Solución sin hacer uso de funciones
...
!
7
!
5
!
3
)
(
7
5
3
+
−
+
−
=
x
x
x
x
x
sen
resul
term
Ciclo para generar el numero de
términos que tendrá la serie
Ciclo anidado para calcular el
factorial(que se usara en el
denominador) y la potencia (que
se usara en el numerador).
Parte que sumara o restara el
termino (term) al acumulador
(resul) usado para almacenar la
solución.

12/03/2022
Solución al problema: funciones
int main() {
instruccion_1;
instruccion_2;
. . .
instruccion_N;
return 0;
}
protipo_funciones;
int main() {
funcion_1();
funcion_2();
. . .
funcion_N();
return 0;
}
funcion_1() {
codigo_funcion_1;
}
. . .
funcion_N() {
codigo_funcion_N;
}

12/03/2022
Solución haciendo uso de funciones
Ciclo para generar el numero de
términos que tendrá la serie
Calculo del factorial y la potencia
usando funciones.
Parte que sumara o restara el
termino (term) al acumulador
(resul) usado para almacenar la
solución.

12/03/2022

12/03/2022
#include <stdio.h>
int a[3],b[3],c[3];
void ingresar_vector(int []);
void imprimir_vector(int []);
void sumar_vectores(int [],int [],int );
int main() {
int i;
printf(" Ingrese el primer vector: ");
ingresar_vector(a);
printf(“vec1 = ”);
imprimir_vector(a);
printf(“nn”);
. . .
return 0;
}
void ingresar_vector(int v[]) {
for(i=0;i<3;i++) {
scanf("%d",&v[i]);
}
}
void imprimir_vector(int v[]) {
printf(“[%d %d %d]”,v[0],v[1],v[2]);
}
void sumar_vectores(int v1[],int v2[],int res) {
for(i=0;i<3;i++) {
res[i]=v1[i]+v2[i];
}
}
Prototipos de las funciones
Función principal
Definición de las funciones

12/03/2022
Implementación de Programas
Utilizando Funciones
• Usualmente los problemas que se resuelven
con un computador son mas grandes y
complejos que los revisados aquí.
• En estos casos, se busca siempre dividir el
problema grande en subproblemas.
• Las funciones son grupos de sentencias bajo
un mismo nombre que nos ayudan en esta
técnica de divide y conquista.
• Son los subproblemas, cada función se
encarga de resolver un problema mas
pequeño.

12/03/2022
• Hemos utilizado funciones que ya han
sido escritas, e incluidas en librerías.
• Una de las funciones que más hemos
utilizado ha sido printf, de la librería stdio,
para mostrar información en pantalla.
• printf nos ayuda a resolver un problema,
tal como lo hace un programa
• De hecho, todos los programas principales
se escriben como una función: main()

12/03/2022
• Las funciones y los programas se parecen
mucho, pero difieren:
– Los programas son usados por un usuario
externo
– Las funciones son utilizadas por un programador
– El usuario del programa “Hola Mundo” no conoce
que es la función printf
– El programador que usa printf no siempre
conocerá explícitamente como ésta hace para
mostrar información en pantalla.
– El programador que escribió printf conoce
exactamente su funcionamiento interno

12/03/2022
tipo_retorno nombre_funcion(tipo_1 param_1,. . ., tipo_N param_N)
{
intruccion_1;
. . .
instrucción_N;
return expresion;
}
Estructura de una función en C
float suma(float num1, float num2) {
float res;
res = num1 + num2;
return res;
}
Cuerpo de la función
Cabecera de la función
Cuerpo de la
función
Tipo de dato retornado
por la función
Nombre de la función
Argumentos de la
función.
Variable retornada por la función

12/03/2022
Estructura de una función en C
float res;
res = num1 + num2;
return res;
}
Tipo de dato retornado
por la función
Nombre de la función
Argumentos de la
función.
Variable retornada por la función
Puede ser cualquier tipo de dato ordinario (int, char, float,
double, etc), un puntero a cualquier tipo de dato, o un dato
tipo struct. Una funcion puede o no retornar un valor.
Puede empezar por una letra o el carácter _.
Después de este puede contener tantas letras
como números o _ se deseen. Si embargo el
compilador ignora a partir de cierta cantidad
Cada parámetro es separado por coma, los
tipos de datos manejados para cada
argumento pueden ser de cualquier tipo de
datos simples o compuestos.

12/03/2022
Conceptos Importantes
• Función
– Grupo de sentencias bajo el mismo nombre
• Llamar a una función
– Ejecutar el grupo de sentencias de una
función. Para lograrlo solo se escribe el
nombre de la función, seguida por una lista
de expresiones, separadas por coma y
encerradas entre paréntesis. Ejemplo
• printf(“%d”, a);
• e = abs(x-y)/ abs(x);

12/03/2022
Conceptos Importantes
• Argumentos
– Se refiere a la lista de expresiones encerradas entre
paréntesis. Permiten pasar la información a la función.
Ejemplo
• printf sabe que imprimir porque se lo indicamos en los
argumentos
– Existen funciones que no necesitan argumentos
• n = GetInteger();
• Retornar
– Una vez “llamada” la función, esta hace su trabajo, y
regresa al mismo punto donde fue llamada. La función ha
“retornado” al punto de llamada, y en la mayoría de los
casos, las funciones envían un valor de retorno.

12/03/2022
Analogía
• Si una función resuelve un determinado problema, se
puede decir que necesita los datos de entrada
(argumentos) y genera una salida (valor que retorna).
• Es similar a cuando un jefe llama a un trabajador para
que efectúe una tarea. Le da las especificaciones
(argumentos) y espera.
• El trabajador a su vez, recibe esta información,
efectúa su trabajo, en la que puede ser que necesite
de la ayuda de otros trabajadores y los “llame”.
• Cuando termina el trabajo, regresa hacia donde su
jefe, y le muestra (retorna) un reporte.
• El jefe nunca supo como el trabajador efectuó su
trabajo o si uso ayuda.

12/03/2022
Argumentos y Retorno: Aclaraciones
• Los datos otorgados a una función, como argumentos,
pudieron ser ingresados, por un usuario externo, mucho
antes de la llamada a la función.
• El resultado que retorna una función, la retorna al programa,
para que se pueda usar en este, cuando se desee. No es
impresa en pantalla, a menos que el programa así lo indique.
void main()
{
double x, y;
printf(“Ingrese un real:”);
x = GetReal();
y = sin(x);
printf(“El seno de x es: %.2f”, y);
}
E/S de datos permiten
a un programa
comunicarse con su
usuario externo
Argumentos y retorno
permiten a una función
comunicarse con el
programa que la llama

12/03/2022
#include <stdio.h>
int main ( )
{
printf (“Hello World!n”) ;
return 0 ;
}
Llamada a funciones
printf es el nombre de una función
predefinida en la librería stdio
esta cadena de caracteres la estamos
pasando como un argumento (parametro)
a la función printf.
Esto sería la llamada a la función
(function call).

12/03/2022
Librería MATH
• La librería math.h permite al programador efectuar cálculos matemáticos
comunes
Numero Descripcion Ejemplo
ceil(x) redondea x al entero mas pequeño no menor
que x
ceil(9.2) es 10.0
ceil(-9.8) es –9.0
floor(x) redondea x al entero mas grande no mayor que
x
floor(9.2) es 9.0
floor(-9.8) es –10.0
fabs(x) valor absoluto de x fabs(-9.5) es 9.5
fmod(x,y) residuo de x/y como numero de punto flotante fmod(13.657, 2.333) es
1.992
sqrt(x) raiz cuadrada de x sqrt(9.0) es 3.0
pow(x,y) x elevado a la potencia y pow(2,7) es 128
log(x) logaritmo natural de x(base e) log10(x)
log10(x) logaritmo de x(base 10) log(2.718282) es 1
exp(x) funcion exponencial exp(0.1) es 2.71828
sin(x) seno trigonometrico de x(en radianes) sin(0.0) es 0.0
cos(x) coseno trigonometrico de x(en radianes) cos(0.0) es 1
tan(x) tangente trigonometrico de x(en radianes) tan(0.0) es 0

12/03/2022
Ejercicio en Clase
• Expresar lo siguiente como una expresión en C
2
2
y
x
distancia +
=
Muestre el valor de x tras la ejecución de las
siguientes sentencias. Asuma x un real
x = fabs(7.5);
x = floor(7.5);
x = ceil(0.0);
x = ceil(-6.4);
x = ceil(-fabs(-8 + floor(-5.5)));



cos
sin
tan =

12/03/2022
Ejercicio
• Una aplicación de la función floor es redondear un valor a
su entero más próximo. La instrucción:
– y = floor(x+0.5);
redondeará el número x al entero más próximo, y asignará
el resultado a y. Escriba un programa que a 5 números los
redondee al número más próximo. Por cada número,
imprima tanto el original como la cifra redondeada.

12/03/2022
Declaración de una función en C
float suma(float num1, float num2);
int max(int x,int y);
void imprimir_saludo(void);
void imprimir_vector(int v[],int long);
int comparar_vectores(int v1[],int v2[]);
• La declaración de una función se denomina prototipo. Básicamente, la
declaración describe la interfaz de la función. Al declarar una función,
básicamente lo que se esta haciendo es especificar la cabecera.
• La forma general de la declaración de una función es:
• Los nombres de los parámetros se suelen omitir.
float suma(float,float);
int max(int,int);
void imprimir_saludo(void);
void imprimir_vector(int [],int);
int comparar_vectores(int [],int []);
tipo_retorno nombre_funcion(tipo_1,. . ., tipo_N);

12/03/2022
Declaración de Funciones
• En C declaramos las variables que vamos a usar
• Así mismo, cuando se escribe una nueva función, esta debe
ser “declarada”.
• Las declaraciones de las funciones de librerías que usamos,
están en su respectivo archivo de cabecera(.h)
• La declaración de una librería es un poco más elaborada que
la de una variable. En una variable solo se indica el tipo y el
identificador. En una función, se debe indicar:
– El nombre de la función
– El tipo de dato de cada argumento, y en muchos casos, un
identificador para cada uno. Aquí los argumentos van separados
con comas.
– El tipo de dato del valor que va a retornar.

12/03/2022
Declaraciones en math.h

12/03/2022
Prototipos de Funciones
• La declaración de una función se conoce como el
prototipo de esa función. Ejemplo:
– double sqrt(double x);
• En un prototipo, es opcional especificar un
identificador para cada argumento.
• Son muy útiles, pues aquel que lo ve, ya puede
intentar usar la función, pues conoce sus argumentos
y el retorno.
• También pueden existir funciones que no tomen
argumentos, en estos casos, en el prototipo se incluye
la palabra void, y por supuesto, sin identificador:
– int GetInteger(void);

12/03/2022
Definición de una función en C
• La definición de la función consiste de la cabecera de la función (declarador)
y un bloque de función. La cabecera de la función especifica el nombre de la
función, el tipo el valor de retorno, y los tipos y nombres de sus parámetros. Las
sentencias del bloque de la función específica lo que hace la función.
• Declarar una función dentro de otra es algo prohibido
• La forma general de la declaración de una función es:
tipo_retorno nombre_funcion(tipo_1 param_1,. . .,
tipo_N param_N) {
intruccion_1;
. . .
instrucción_N;
return expresion;
}
float res;
res = num1 + num2;
return res;
}

12/03/2022
Creando Funciones
• Ya sabemos usar funciones de librerías, pero llega un
punto en la vida de un programador que deseará
escribir sus propias funciones.
• Vamos a escribir una función:
– Se nos ha asignado escribir un programa que convierta
una temperatura en Celsius a Fahrenheit. Esto se logra
con la fórmula.
• Seria ideal escribir una función que se encargue de
eso, y luego poder usarla cuando deseemos.
32
5
9
+
= C
F

12/03/2022
Creando Funciones
• Para crear una nueva función se debe seguir los pasos:
– Especificar el prototipo de la función: Declararla. Esto
se hace normalmente luego de las líneas de #include,
antes del programa principal.
– Especificar los pasos de la función, como esta llevara a
cabo su tarea: Implementarla
• En nuestro caso, para declarar el prototipo debemos
pensar
– Que necesitamos que la función genere:
• La temperatura en Fahrenheit(real)
– Que necesita la función para generar esa información:
• La temperatura en Celsius(real)
double CelsiusAFahrenheit (double c);

12/03/2022
Implementación
• Se puede decir que la implementación se
compone de dos partes:
– La cabecera, que luce igual que el prototipo, siempre
con identificadores para cada argumento, y sin el ; al
final
– El cuerpo, que es un bloque de sentencias, por lo
tanto encerrado entre llaves. Si se van a necesitar
variables, se declaran en el bloque.
double CelciusAFahrenheit(double c)
{
/*Cuerpo*/
}

12/03/2022
• Si la función debe generar un valor, esta lo retornará
usando la sentencia return dentro del cuerpo de la
función.
• La forma de usarla es:
return (expresión que se debe retornar);
• Esto especifica que la función debe terminar, retornando
el valor calculado.
• Hay funciones que no retornan datos, en este caso, se
puede usar return, pero sin mencionar una expresión.
return;
¿Cómo Retornar?

12/03/2022
Implementación y Uso
• La función ya esta implementada, lista para
ser usada (llamada) desde cualquier parte.
• Usemos esta función para escribir una tabla
de conversión de temperatura desde los 0°C
a los 100°C, de 5 en 5.
double CelsiusToFahrenheit(double c)
{
return (9.0 / 5.0 * c + 32);
}

12/03/2022
Uso de funciones en C
• Una función debe ser declarada antes de ser usada, por ello suele ser
común colocar las declaraciones antes de la función main.
protipo_funciones;
int main() {
funcion_1();
funcion_2();
. . .
funcion_N();
return 0;
}
funcion_1() {
codigo_funcion_1;
}
. . .
funcion_N() {
codigo_funcion_N;
}
int main() {
. . .
return 0;
}
float suma(float num1, float num2)
{
float res;
res = num1 + num2;
return res;
}

12/03/2022
Invocación (llamada) de funciones en C
• Una vez que se han implementado las funciones el siguiente paso consiste en
usarlas (es decir invocarlas).
• Cuando se ejecuta un programa la primera función que se ejecuta es la función
main, por ello su importancia.
• Una función puede invocar otra función.
#include <stdio.h>
int main() {
f1();
f2();
return 0;
}
f1(){
. . .
}
f2() {
f3()
. . .
}
main()
f1()
f2()
f3()
1
0
2
3
4
5
6
7

12/03/2022
Invocación (llamada) de funciones en C
#include <stdio.h>
int main() {
int a = 3, b = 2, c = 0, d = 3;
int e, f, g, h, i, k;
d = suma(2,-4);
c = suma(a,b);
f = suma(2,c++);
g = suma(++c,d++);
h = suma(suma(1,a),d);
suma(2,3);
return 0;
}
float res;
res = num1 + num2;
return res;
}
Una función se puede invocar
las veces que se desee.
Cuando se invoca un función
que retorna un valor se es
libre de llevar el valor
retornado a una variable.

12/03/2022
#include <stdio.h>
#define LIMITEINF 0
#define LIMITESUP 100
#define PASO 5
// Prototipos de Funciones
double CelsiusAFahrenheit(double c);
/* Programa Principal */
void main()
{
int c;
printf(“Tabla de conversion de Celsius a Fahrenheit.n”);
printf(“C Fn”);
for(c = LIMITEINF; c <= LIMITESUP; c = c + PASO)
printf(“%3d %3gn”,c, CelsiusAFahrenheit(c));
}
/*
* Funcion CelsiusAFahrenheit
* Uso: f=CelsiusAFahrenheit(c);
* Esta función retorna el equivalente en Fahrenheit del valor c
en Celsius
*/
double CelsiusAFahrenheit(double c)
{
return (9.0 / 5.0 * c + 32);
}
Uso de una Función

12/03/2022
Funciones más Complejas
• Nuestra nueva función resuelve un problema
sencillo.
• Las funciones usualmente son mas
complejas, y en su código incluyen las
sentencias de control.
• Además, las funciones no sólo retornan
valores enteros, también pueden retornar
cadenas o valores lógicos.
• EJERCICIO
– Escribir una función MinR en C que indique el
menor valor entre dos valores reales.

12/03/2022
Ejercicio en Clase
• Escribir la función Factorial en C que permita calcular el
factorial de un numero dado.
– El factorial de 0 es 1
– El factorial de 1 es 1(1x1)
– El factorial de 2 es 2(1x2)
– El factorial de 3 es 6(1x2x3)
– El factorial de 4 es 24(1x2x3x4)
– El factorial de un número dado es la multiplicación de todos los
números desde el 1 hasta el mismo.

12/03/2022
Solución
int Factorial(int n)
{
int fact, i;
fact = 1;
if (n==0)
return 1;
for(i = 1; i <=n; i++)
fact = fact * i;
return (fact);
}
Inicio
Fin
Recibir n
i >=n
fact = fact * i;
Retornar fact
i = i +1;
Fact = 1;
i = 1;

12/03/2022
Retornando Cadenas
• Escribir una función en
C que dado un mes (6,
7, 12 ..) retorne su
respectivo nombre
(Junio, Julio,
Diciembre..)
– Debe generar la cadena
del nombre del mes
– Debe recibir el número
del mes, un entero.
• El prototipo sería:
string NombreDeMes(int mes);
string NombreDeMes(int mes)
{
switch(mes)
{
case 1:
return(“Enero”);
break;
case 2:
return(“Febrero”);
break;
case 3:
return(“Marzo”);
break;
case 4:
return(“Abril”);
break;
case 5:
return(“Mayo”);
break;
case 6:
return(“Junio”);
break;
case 7:
return(“Julio”);
break;
case 8:
return(“Agosto”);
break;
case 9:
return(“Septiembre”);
break;
case 10:
return(“Octubre”);
break;
case 11:
return(“Noviembre”);
break;
case 12:
return(“Diciembre”);
break;
default:
return(“Mes no v%clido”,160);
}
}

12/03/2022
Utilizando la nueva función
#include <stdio.h>
#include <simpio.h>
// Declaración de Funciones
string NombreMes(int mes);
void main()
{
int mes,dia,anio;
printf(“Ingrese el dia actual:”);
dia = GetInteger();
printf(“Ingrese el mes actual:”);
mes = GetInteger();
printf(“Ingrese el anio actual:”);
anio = GetInteger();
printf(“La fecha ingresada es: %s %d de %d”, NombreMes(mes), dia, anio);
}

12/03/2022
Retornando Bool
• Si las funciones pueden retornar enteros, y
cadenas, porque no van a poder retornar
valores lógicos (bool).
• Las funciones que retornan valores lógicos
se conocen como funciones de predicado.
• Llamar a una función de predicado es
equivalente a hacer una pregunta donde la
respuesta puede ser Verdadera (TRUE) o
Falsa (FALSE).

12/03/2022
Ejercicios en Clase
• Escribir una función en C que permita
determinar si un número es par.
• Escribir una función en C que permita
determinar si un año es bisiesto.
• Escribir un programa imprima los números
pares hasta el 10.
• Escribir un programa que imprima los
años bisiestos desde 1960 hasta el año
actual.

12/03/2022
Solución
bool EsPar(int n)
{
return (n%2==0);
}
bool EsBisiesto(int anio)
{
return (((anio%4==0)&&(anio % 100!=0) ) || ((anio%400)==0));
}
main()
{
int i;
for(i = 1; i <=10; i++)
{
if(EsPar(i)) printf(“%dn”,i);
}
}
main()
{
int i;
for(i = 1960; i <=2004; i++)
{
if(EsBisiesto(i)) printf(“%dn”, i);
}
}

12/03/2022
Comparando Cadenas
• Ahora que ya sabemos más de las funciones,
estamos listos para conocer algo más de las cadenas.
• Los operadores relacionales, sólo pueden aplicarse
sobre tipos de datos atómicos, y eso dejaba de lado a
las cadenas.
• La única forma, por ejemplo, de determinar la
equivalencia de dos cadenas, seria a través de una
función.
• StringEqual es la función de la librería genlib, que
permite este tipo de comparaciones.
– Compara dos cadenas, que debe recibir como argumentos
– Decide si son o no iguales (VERDADERO O FALSO)
– Es una función predicado
bool StringEqual(string s1, string s2);

12/03/2022
Ejercicio en Clase
• Escriba un programa que sume un grupo
de números enteros ingresados por
teclado. El programa deber permitir el
ingreso del número, y luego preguntarle al
usuario si desea seguir ingresando. Si la
respuesta es no, el programa debe
terminar.

12/03/2022
Solución
void main()
{
int suma, n;
string respuesta;
suma = 0;
while(TRUE)
{
printf(“?”);
n = GetInteger();
suma = suma + n;
printf(“Desea seguir ingresando:”);
respuesta = GetLine();
if(StringEqual(respuesta,”no”))
break;
}
printf(“La suma es:%d”,suma);
}
inicio
Escribi
r(“?”)
Suma = 0
Leer(n)
;
suma =
suma + n
Escribir(“De-
sea seguir?”)
Respuesta
== “no”
Escribi
r(sum
a)
fin
Leer(res
-puesta)

12/03/2022
• Hay una mayor complejidad de la mostrada, en el uso de funciones
• Tomemos como ejemplo el siguiente programa:
#include <stdio.h>
#include <simpio.h>
//Declaración de funciones
int Factorial(int n);
void main()
{
int i;
for (i = 0; i < 10; i ++)
printf(“%dn”, Factorial(i));
}
int Factorial (int n)
{
int fact, i;
fact = 1;
for(i = 1; i <=n; i++)
fact = fact * i;
return (fact);
}
Si vemos sólo la
función, tiene sentido,
pues se encarga de
calcular el factorial de
la variable n
Si vemos sólo el programa
principal, tiene sentido, pues
se imprime el factorial de
todos los números hasta el 10
Si vemos el
programa principal y
la función como un
todo, puede resultar
un tanto confuso:
• Hay dos
variables con
nombre i
• En el programa se
usa la variable i
como el número al
que se le calcula el
factorial.
• En la función la
variable a la que
se le calcula el
factorial se llama n
La Verdad detrás de las Funciones

12/03/2022
Paso de Argumentos a Funciones
#include <stdio.h>
#include <simpio.h>
//Declaración de funciones
int Factorial (int n);
void main()
{
int i;
for (i = 0; i < 10; i ++)
}
int Factorial (int n)
{
int fact, i;
fact = 1;
for(i = 1; i <=n; i++)
fact = fact * i;
return (fact);
}
En el programa principal, se calcula el
factorial de i.
En la función se calcula el factorial de n
¿Cómo es que hay diferentes
identificadores para el mismo valor?
La respuesta esta muy relacionada con el
concepto de argumento:
- En el programa principal, i representa el
argumento enviado a la función Factorial.
- En la función Factorial, alguna variable
debe recibir el enviado, para representar
dicho valor. Esta variable puede tener
cualquier nombre, en este caso se le dio
el nombre n.
- Una variable definida en la cabecera de
una función, que sirve para recibir el valor
de un argumento, se conoce como
parámetro.

12/03/2022
#include <stdio.h>
#include <genlib.h>
main()
{
int i;
for (i = 0; i < 10; i ++)
{
}
}
{
int fact, i;
fact = 1;
for(i = 1; i <=n; i++)
{
fact = fact * i;
}
return (fact);
}
Factorial(0)
n
0
n
1
n
2
Factorial(1)
Factorial(2)
expr
1
expr
1
expr
2
Factorial(3)
n
3
expr
6
1
1
2
6
Pasos para llamar a una Función
• Se evalúan las
expresiones enviadas
como argumentos.
• El valor de cada
argumento es copiado en
orden en cada parámetro
correspondiente de la
función llamada.
• Se ejecutan una a una las
sentencias del cuerpo de
la función hasta que
aparece la sentencia
return.
• Se evalúa la expresión de
la sentencia return.
• El programa que llamó a
la función continúa,
reemplazando en el lugar
de la llamada, el valor
retornado

12/03/2022
Manejo de Variables Dentro de las
Funciones (Variables Locales)
• En la función Factorial se usa una variable i, y en el programa
principal se usa otra variable i, pero no parece que se usaran para
lo mismo, ¿son diferentes?.
• De hecho, si son diferentes.
– Cada función puede usar sus propias variables, y estas sólo serán
válidas dentro de la función, se conocen como variables locales.
main
i
0
Al llamar a la función Factorial, se crean 3
variables locales a Factorial, pueden tener
cualquier nombre, en este caso: n, fact e i.
Las variables locales del main aun existen,
pero, no se pueden ver mientras Factorial
este activa.
Cuando todo Factorial termina, retorna el
valor, y las variables locales al main
permanecen iguales como antes de la
llamada.
La variable i es local
a la funcion main
Factorial
n fact i
0 1 1
main
i
0
La variable i es local
a la funcion main

12/03/2022
Ejercicio en Clase
• Suponga que tienen un grupo de 5 monedas americanas:
penny(1 centavo), nickel(5 centavos), dime(10 centavos),
quarter(25 centavos). Se desea conocer de cuantas formas
diferentes, estas se pueden combinar, para formar un par. Se
pueden tomar penny y nickel, o penny y dime, etc
• En este ejemplo n es 5 y k es 2. La solución de cuántas
combinaciones se puede expresar usando:
• Escriba una función en C que permita calcular cuántas
combinaciones de k miembros se pueden generar teniendo n
objetos.
)!
(
!
!
)
,
(
k
n
k
n
k
n
C
−

=

12/03/2022
Llamando Funciones desde otras
Funciones
• Hasta ahora solo hemos hecho llamadas a funciones desde el
programa principal
• Pero las funciones se pueden llamar desde cualquier parte del
programa, incluso desde otras funciones.
• En este ejemplo, la función necesita recibir el número de objetos (n)
y el número de miembros (k) de cada combinación, para poder
retornar el número de combinaciones posibles. El prototipo:
int Combinaciones (int n, int k)
{
return(Factorial(n)/(Factorial(k)*Factorial(n-k));
}
int Combinaciones (int n, int k);
La implementación se podría lograr, usando la función Factorial que
ya fue implementada:

12/03/2022
Un Programa Completo
• A continuación la implementación
completa de un programa que hace uso
de la función Combinaciones:
• Nota:
– A este programa le faltan las validaciones de
las respectivas entradas.

12/03/2022
#include <stdio.h>
#include <genlib.h>
#include <simpio.h>
/* Prototipos de Funciones */
int Combinaciones(int n, int k);
/* Programa Principal */
void main()
{
int n, k;
printf(“Ingrese el numero de objetos(n) ?”);
n = GetInteger();
printf(“Ingrese el numero de miembros de la combinacion(k) ?”);
k = GetInteger();
printf(“C(%d,%d) = %dn”,n,k,Combinaciones(n,k));
}
/*
* Funcion Combinaciones
* Uso: c = Combianciones(n,k);
* Calcula el numero de combinaciones distintas, para elegir k objetos de un grupo de n
*/
int Combinaciones(int n, int k)
{
return(Factorial(n)/(Factorial(k)*Factorial(n-k));
}
/*
* Funcion Factorial
* Uso: f = Factorial(n);
* Retorna el factorial del argumento n
*/
{
int fact, i;
fact = 1;
for(i = 1; i <=n; i++)
{
fact = fact * i;
}
return (fact);
}

12/03/2022
Procedimientos
• Hemos visto que existen funciones que no retornan ningún
valor, como printf:
– printf (“Hola Mundon”);
• A este tipo de funciones que no retornan nada, y que se
llaman únicamente para que ejecuten su código, se les llama
procedimientos.
• Muchos lenguajes de programación separan totalmente el
concepto de funciones, con el de procedimientos, pero C las
trata de igual forma.
• Un procedimiento en C, es una función sin valor de retorno.
– void DarInstrucciones(void);
• Los procedimientos pueden recibir tantos argumentos
necesite.

12/03/2022
void ImprimirMenu (void)
{
printf (“1. Tabla de Sumarn”);
printf (“2. Tabla de Restarn”);
printf (“3. Tabla de Multiplicarn”);
printf (“4. Tabla de Dividirn”);
printf (“5. Salirn”);
}
Implementación de Procedimientos

12/03/2022
Refinamiento
• Cuando un problema es muy grande, se busca separarlo,
para resolver todo por partes. Esto es ventajoso
– Las partes más pequeñas son mas fáciles de entender
– Si algo falla, el error es mas fácil de encontrar
• Esto se conoce como descomposición de un problema
• Al escribir un programa, usualmente se piensa en el
programa principal (main),y se piensa en las tareas más
importantes
• Se piensa en dividir el programa en componentes
individuales, los cuales pueden ser a su vez, divididos en
piezas más pequeñas.
• Esto se conoce como diseño top-down, o refinamiento
paso a paso.

12/03/2022
• Se requiere escribir un programa que muestre el calendario completo
de un año dado, que no puede ser menor a 1900.
Dar Instrucciones
Ingreso y
Validacion de Año
Imprimir Mes
Mostrar Nombre del
Mes
Determinar que dia
de la semana fue el
primer dia del mes
Dar el respectivo
marqen para el
primer dia del mes
Un Problema más Grande

12/03/2022
Calendario
Dar Instrucciones Pedir Año Imprimir Calendario
Imprimir Nombre
del Mes
Determinar
cuantos días trae
el mes
Determinar el dia
de la semana
donde cayo el
primer dia
Imprimir el Margen
para el primer dia
del mes
Imprimir Calendario de c/ Mes
Imprimir el
resto de
días
Dependiendo del
mes y de si es
bisiesto, elegir total
de días
Calcular el dia de la
semana del primer dia
del año, contando el
total de días desde
1900 hasta el año
actual, considerando los
años bisiestos
Calcular el dia de la
semana del primer dia del
mes, sumándole al primer
dia del año, el total de días
hasta el mes actual,
considerando el total de
días de cada mes

12/03/2022
Conclusiones del Refinamiento
• Del refinamiento podemos sacar las funciones que necesitaremos:
– Dar instrucciones:
• void DarInstrucciones(void)
– Pedir año(y validarlo):
• int PedirAnio(void);
– Imprimir todo el Calendario de un año
– void ImprimirCalendario(int anio);
• Imprimir el Calendario de un mes, de un año dado
– void ImprimirCalendario(int mes, int anio);
• Conseguir el nombre de un numero de mes dado
– string NombreDeMes(int mes);
• Determinar el numero de la semana donde cayo el primer día
– int PrimerDiaDelMes(int mes, int anio);
• Imprimir margen para primer día
– void ImprimirMargen(int dia_semana);
– FUNCIONES QUE AYUDAN
• Determinar si un año es bisiesto
– bool EsBisiesto(int anio);
• Determinar el numero de días de un mes, de un año dado
– int DiasDeMes(int mes, int anio);

12/03/2022
Contenido
• Recursividad

12/03/2022
Recursión
• La estrategia a seguir es la delegación de
tareas.
• Es decir que un problema grande se
subdivide en pequeñas tareas, y éstas se
delegan.
• Implica llamar al mismo procedimiento
varias veces.

12/03/2022
La Función Factorial
• Esta función fue implementada
anteriormente con un lazo for.
• La propiedad primordial del factorial es
que está relacionada a su anterior valor
n!=n*(n-1)!
• La función factorial se define como:
n! = 1 si n=0
n*(n-1)! En otro caso

12/03/2022
La Función Factorial
• Dicha definición es recursiva, porque n! está
en términos de (n-1)!, lo cual tiene la misma
forma del original.
• La implementación de la función en C
usando recursión sería:
{
if(n==0){
return(1);
} else{
return(n*Factorial(n-1));
}
}

12/03/2022
Manejo Interno de la Recursión
• En el proceso de encontrar la respuesta,
el computador va hacia los procesos
internos, que son las llamadas al mismo
procedimiento una y otra vez.
• Supongamos que se quiere evaluar
fact= Factorial(4);
• En el programa principal se hace la
primera llamada a la función.

12/03/2022
Primera llamada
main
Factorial
4
n if(n==0){
return(1);
} else{
}
?
La función llama a Factorial(n-1), y tan pronto
ésta regrese, se ejecuta la operación indicada

12/03/2022
Segunda llamada
main
Factorial
3
n if(n==0){
return(1);
} else{
}
?
Factorial
Igualmente al anterior caso, aquí se hace otro
llamado interno a la función, y la operación no se
realiza hasta que se retorne dicho valor

12/03/2022
Tercera llamada
main
Factorial
2
n if(n==0){
return(1);
} else{
}
?
Factorial
Siguiendo la lógica, se llama a Factorial(1), y éste a su vez
llama a Factorial(0), realizándose dos llamadas más a la
función
Factorial

12/03/2022
Última llamada
Factorial
0
n if(n==0){
return(1);
} else{
}
Factorial
Factorial
main
Factorial
Factorial
En este punto, la situación
varía, como n es 0, la función
retorna su resultado
inmediatamente
return(1);

12/03/2022
Retorno
Factorial
1
n if(n==0){
return(1);
} else{
}
Factorial
Factorial
Factorial
main
1
Desde este punto, se devuelve el retorno a cada
llamada recursiva
return(1*1);

12/03/2022
Retorno
main
Factorial
2
n if(n==0){
return(1);
} else{
}
1
Factorial
Factorial
return(2*1);

12/03/2022
Retorno
Factorial
3
n if(n==0){
return(1);
} else{
}
2
Factorial
main
return(3*2);

12/03/2022
Retorno
main
Factorial
4
n if(n==0){
return(1);
} else{
}
6
return(4*6);

12/03/2022
El Paradigma Recursivo
• Toda función recursiva tiene la siguiente
estructura:
if(Prueba para el caso simple){
return(solución simple sin usar recursión);
} else{
return(solución recursiva llamando a la misma función);
}

12/03/2022
Otro Ejemplo de Recursión
• Otro ejemplo recursivo es el de elevar un
número entero a una potencia k.
• Su definición es:
nk= 1 si K=0
nxnk-1 en otro caso
La solución recursiva de este problema es
como sigue...

12/03/2022
Otro Ejemplo de Recursión
static int ElevarEnteroPotencia(int n, int k)
{
if(k==0){
return(1);
} else{
return(n* ElevarEnteroPotencia(n, k-1))
}
}

12/03/2022
Consideraciones
• Los problemas vistos, de factorial y número
elevado a una potencia, tienen soluciones
recursivas naturales, porque:
• Se puede identificar el caso más simple.
• Se puede aplicar recursividad para
descomponer el problema en más simples del
mismo tipo.
• Existen otros problemas en los que la recursión
es un poco más difícil de ver, para tales caso
permutaciones son usadas.

12/03/2022
Contenido
• Recursividad

12/03/2022
Paso de Parámetros
• Hasta ahora vimos y hemos usado una forma sencilla de pasar parámetros a las
funciones
• Cada parámetro de una función espera y recibe una copia del valor de cada
argumento enviado.
• Ejemplo: Cree una función que reciba dos
valores y los intercambie.
• Podríamos decir que el prototipo seria:
– void Intercambiar(int a, int b);
• Al retornar la función no efectuaría el
cambio, como lo deseamos. Recordemos
que, al pasar parámetros, se efectúa una
copia de los valores. Este tipo de paso de
parámetros se conoce como PASO DE
PARAMETROS POR VALOR
x
main
y
3 4
Intercambiar
a b tmp
3 4
3 3
4
x
main
y
3 4
main()
{
int x, y;
printf(“Ingrese x:”);
x = GetInteger();
printf(“Ingrese y:”);
y = GetInteger();
printf(“x = %d, y= %d”, x, y);
Intercambiar(x,y);
}
void Intercambiar(int a, int b)
{
int tmp;
tmp = a;
a = b;
b = tmp;
}

12/03/2022
Otra Forma de pasar Parámetros
• El intercambio en la función anterior no se realiza porque jamás se
trabajó con los argumentos.
• En el paso de parámetros por valor, la función trabaja con una copia
de los argumentos.
• Si deseamos que una función manipule sus parámetros, y esto se
refleje en los argumentos, se usa PASO DE PARÁMETROS POR
REFERENCIA. En este caso:
– La función no trabaja con copias
– Trabaja directamente con los argumentos
– La función no recibe valores, sino que recibe direcciones de memoria…
es decir: punteros

12/03/2022
El Intercambio
x
main
y
• Para este tipo de problemas, en los cuales necesitamos modificar directamente
los datos que se reciben como parámetros, se usa la PASO DE
PARÁMETROS POR REFERENCIA
• Si la función no va a recibir valores, si no direcciones, el prototipo seria:
void Intercambiar(int *a, int *b);
3 4
• Los parámetros a y b son ahora
punteros, que representan a los
argumentos directamente
• Cualquier cambio que se haga sobre
a y b se esta haciendo realmente a
las variables a las que estos apuntan
Intercambiar
*a *b tmp
4 3
3 4
3 3
4
x
3 4
3
main
y
4 3
main()
{
int x, y;
printf(“Ingrese x:”);
scanf(“%d”,x);
printf(“Ingrese y:”);
scanf(“%d”,y);
Intercambiar(&x,&y);
}
void Intercambiar(int *a, int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
En este caso:
a apunta a x,
b apunta a y
a = &x, b = &y
No se envían
valores, se
envían
direcciones

12/03/2022
Un Uso Mas Interesante
• El paso de parámetros por referencia es útil:
– Cuando deseamos intercambiar valores
– Cuando deseamos que una función retorne mas de un valor
• Como todos sabemos las funciones solo pueden retornar un valor
• Si necesitamos que una función retorne mas de un valor, aquellos
valores que necesitamos retornar, deben ser parámetros por
referencia.
• EJERCICIO EN CLASE
– Crear una función que calcule el menor, el mayor y el promedio de un
arreglo
• Esta función debe retornar 3 valores, usemos parámetros por
referencia
• Si la función retorna mas de 1 valor, podemos declararla como
void…convirtiéndose en un procedimiento.
• void CalcularValores(int arreglo[], int n, int *mayor, int *menor,
int *promedio);
Los datos que
vamos a
retornar, se
declaran como
parámetros
por referencia

12/03/2022
Solución
• Los cálculos hechos se almacenaran en los parámetros
por referencia:
void CalcValores(int arr[], int n, int *menor, int *mayor, float *promedio){
int i, total;
*menor = arr[0];
*mayor = arr[0];
total = 0;
for(i = 0; i < n; i++){
if(arr[i] < *menor) *menor = arr[i];
if(arr[i] > *mayor) *mayor = arr[i];
total = total + arr[i];
}
*promedio = total/ n;
}
La función no tiene
explícitamente una
sentencia return.
Se trabaja
directamente con los
parámetros recibidos.
Estos son direcciones,
para trabajar con ellas,
usamos el operador *

12/03/2022
Advertencia
• El paso de parámetros por referencia no debe
reemplazar al paso de parámetros por valor.
• Solo se usan parámetros por referencia cuando
sea imperiosamente necesario.
• Las funciones, aquellas que retornan valores son:
– Fáciles de entender y seguir por cualquier
programador.
– El valor que retornan se puede asignar a una
variable.
– No así con los procedimientos.

12/03/2022
Contenido
• Sub-programas Funciones y Procedimientos.
• Recursividad

12/03/2022
Diseño De Una Interfase
• Las funciones y los procedimientos nos
ayudan a reducir la complejidad de los
programas.
• Una interfase le da a un programador
cliente, acceso a un grupo de funciones.
• Para añadir una función a una interfase,
debemos hacerlo con un cierto criterio.

12/03/2022
Criterios Para Diseñar una Interfase
• Una interfase bien diseñada, debe cumplir
los siguientes requisitos:
– Unificación
– Simplicidad
– Suficiencia
– Generalidad
– Estabilidad

12/03/2022
Unificación
• Las funciones (herramientas) dentro de una
librería, deben ser escogidas, de acuerdo a un
cierto tema.
• La unificación también se refiere al enfoque que
se le da a un problema dentro de la misma
librería.
• Por ejemplo:
– Todas las funciones de la librería grafica consideran
que las coordenadas están especificadas en píxeles,
y que la coord. 0,0 esta ubicada en la esquina
superior izq. de un objeto.
– Una función que trabaje con coordenadas en
pulgadas, no conservaría la unificación.

12/03/2022
Simplicidad
• Al diseñar una interfase, el objetivo principal es reducir la
complejidad, a través del uso de ciertas funciones.
• Se trata de proteger al cliente de los detalles complicados.
• La complejidad de la implementación se queda en el lado del
creador de la librería.
• Se “esconde” información del cliente, no se mencionan
detalles en la interfase, ni siquiera a través de comentarios.
• Las funciones también deben ser diseñadas lo más simples
posibles:
– Reduciendo el número de parámetros al mínimo.
– Limitando el total de funciones de la interfase, para no abrumar
al cliente y confundirlo.

12/03/2022
Suficiencia
• Que exista simplicidad, no implica que se debe sacrificar la
suficiencia.
• Al cliente se lo debe proveer de la mayor cantidad de
posibilidades de trabajo.
• Negarle a un cliente una posibilidad de trabajo es fracasar en
el diseño de una interfase.
• Además de que las posibilidades estén disponibles, estas
deben funcionar eficientemente.
• El cliente debe poder confiar en que los resultados dados por
una librería, siempre serán correctos, y que llegaran a el a
tiempo.
• Estos detalles tienen más que ver con la implantación que
con la interfase, pero son estrategias que no debemos pasar
por alto.

12/03/2022
Generalidad
• Una interfase que solo se adapta a las
necesidades de un cliente en particular, puede
que no sirva para otros.
• Una interfase debe ser lo suficientemente general,
para resolver un buen grupo de posibilidades.
• Al crear una interfase debemos olvidarnos de
nuestro punto de vista y ponernos en el lugar de
todos los posibles clientes.

12/03/2022
Estabilidad
• Si la interfase no cambia, los clientes no tienen
porque cambiar sus programas.
• Un creador puede perfectamente hacer cambios a
su librería, y si diseño correctamente su interfase,
estos cambios no afectarán a los clientes.
• Los cambios que haga el creador se harán en la
implementación de la librería.
• Cuando se haga un cambio en la interfase, todos
los clientes deberán cambiar sus programas.
• Usualmente estos cambios son profundos y no se
hacen frecuentemente.

12/03/2022
Al Azar
• Todos hemos usado juegos de computadoras.
• El buscaminas, por ejemplo:
– Nunca se repiten las localidades de las minas.
– Estas fueron ubicadas al azar.
• Lograr que la computadora simule un
comportamiento “al azar” o “aleatorio” es muy útil
para ciertas aplicaciones.
• Sin embargo, esto encierra un cierto nivel de
complejidad.
• Deseamos esconder esa complejidad, usando una
interfase.

12/03/2022
Números Pseudo-Aleatorios
• Un comportamiento determinístico es aquel,
en que las acciones son completamente
predecibles.
• Las computadoras tienen un comportamiento
determinístico, no pueden generar resultados
impredeciblemente.
• Pero pueden simularlo, partiendo de un
procedimiento determinístico. Los números
generados, parecerán ser aleatorios.

12/03/2022
Generación de Números Aleatorios
• La librería en stdlib, incluye en su interfase la función:
– int rand(void);
• El entero que retorna es un número pseudo aleatorio no negativo, ni mayor
a una constante RAND_MAX
#include <stdio.h>
#include <stdlib.h>
#include <genlib.h>
void main()
{
int i, r;
printf("En esta computadora RAND_MAX: %d",
RAND_MAX);
for(i = 0; i < 10; i++)
{
r = rand();
printf("%dn",r);
}
}

12/03/2022
Ejercicio En Clase
• Escribir un programa que simule el lanzamiento de una moneda. El
programa deber “lanzar” 10 veces una moneda e indicar si cayo “Cara”
o “Cruz”.
• Para resolver este problema debemos recordar que rand() nos da un
numero entre 0 y RAND_MAX, es decir, RAND_MAX + 1 posibilidades.
• Nosotros, no deseamos RAND_MAX + 1, deseamos, 2 posibilidades:
RAND_MAX
0 RAND_MAX/2
CARA CRUZ
Podríamos decir, que todos los números menores o iguales que
RAND_MAX/2 representarían la opción 1(Cara) y
Todos los números mayores que RAND_MAX/ 2 representarían la opción
2(Cruz).

12/03/2022
Solución
#include <genlib.h>
#include <stdio.h>
#include <simpio.h>
#include <stdlib.h>
void main()
{
int i, r;
printf("Simulacion del lanzamiento de Monedasn");
for(i=1; i <= 10; i++){
printf("Lanzamiento No. %dn",i);
r = rand();
if(r<=RAND_MAX/2){
printf("CARAn");
} else {
printf("CRUZn");
}
}
}

12/03/2022
Ejercicio En Clase
• Estuvo bien, y acertada nuestra decisión de dividir para 2,
pues las posibilidades casi se repartieron por la mitad.
• Escribir un programa que simule el lanzamiento de un dado, e
indique el número de lado en que cayo.
• Recordemos, ahora si tenemos 6 posibilidades, deberíamos
dividir nuestro rango, para 6
El tamaño de cada division td =
RAND_MAX/6
td 2*td 3*td 4*td 5*td
0 RAND_MAX
1 2 3 4 5 6

12/03/2022
Solución
#include <stdio.h>
#include <stdlib.h>
void main()
{
int r,td;
td = RAND_MAX/6;
printf("Simulacion del lanzamiento de un Dadon");
r = rand();
if(r<=td){
printf("Lado 1n");
}else if(r<=td*2){
printf("Lado 2n");
}else if(r<=td*3) {
printf("Lado 3n");
}else if(r<=td*4) {
printf("Lado 4n");
}else if(r<=td*5) {
printf("Lado 5n");
}else {
printf("Lado 6n");
}
}

12/03/2022
El Problema y su Generalización
• Ahora pensemos en otro tipo de aplicación. Se nos pide escribir un
programa que “escoja” una carta de un mazo:
– En ese caso, la computadora debería generar un número entre 1 y 52.
– Seguir el mismo proceso anterior, con 52 posibilidades significaría
escribir muchas líneas de código.
• Se necesita ahora, escribir un programa que simule el modelo de la
ruleta Europea, donde el rango es de 0 a 36:
– Aunque el procedimiento es parecido, el programa anterior es
completamente inútil.
• Debe existir una forma de generalizar el proceso de limitar el rango
de un número generado aleatoriamente:
– La forma más correcta de generalizar algo para su uso continuo, es a
través de una función.
– Cualquier aplicación que necesite generar un número aleatorio en un
rango dado, podrá usar nuestra nueva función.

12/03/2022
d
Una Nueva Herramienta
• Nuestra función generará un número entero, en un rango dado por un limite
inferior y uno superior:
– int RandomInteger(int v_inf, int v_sup);
• El proceso a seguir es el siguiente:
– Generar un entero entre 0 y RAND_MAX(r)
– Normalizar r, para convertirlo en un número real d entre 0 y 1( 0 <= d < 1)
– Escalar el valor d, multiplicándolo por el tamaño del rango deseado, esto ubicará a
d en el rango de 0 a v_sup-v_inf
– Truncar el valor generado, pues deseamos generar un entero(k)
– Trasladar el entero(k) al rango correcto, de v_inf a v_sup
0 RAND_MAX
r
1
v_sup-v_inf
d
v_sup
v_inf k

12/03/2022
Implementación
int RandomInteger(int v_inf, int v_sup)
{
int r,k;
double d;
r = rand();
d = (double) r / (double) (RAND_MAX +1);
d = d * (v_sup-v_inf+1);
k = (int) d + v_inf;
return k;
}

12/03/2022
Usando La función
• Simulación del lanzamiento de 10 monedas
int RandomInteger(int v_inf, int v_sup);
main(){
int i, r;
printf("Simulacion del lanzamiento de Dadosn");
for(i = 1; i <=10; i++){
printf("Lanzamiento No. %d:", i);
r = RandomInteger(1,6);
printf("Lado %dn",r);
}
}

12/03/2022
Otro Problema sobre el mismo Tema
• Que esperamos que suceda cuando
volvamos a correr el programa cliente?.
• Lo normal, es esperar que el computador
genere otra tanda de números en un orden
completamente diferente.
• Recordemos, que el computador solo puede
simular que genera números al azar.
• Con cada “corrida” del programa, el
computador generará el mismo grupo de
números.

12/03/2022
La Semilla de la Generación
• El proceso básico con el cual el computador “genera” números “al
azar”, es partiendo de un número inicial.
• Usando ese número, la computadora efectúa sus cálculos, y nos
muestra un número que no esperábamos.
• Su nuevo número “inicial” es ahora el último valor calculado.
• Este número “inicial” que la computadora usa para sus cálculos, se
conoce como “semilla”.
• A menos que se indique la computadora siempre usará la misma
semilla en cada “corrida” de un programa.
Proceso de
Calculo
SEMILLA VALOR “AL
AZAR” No. 1
Proceso de
Calculo
VALOR “AL
AZAR” No. 1
VALOR “AL
AZAR” No. 2

12/03/2022
Como Cambiar La Semilla
• La librería stdlib provee una función con la que podemos cambiar la
semilla:
– void srand(int);
• La semilla debe ser un entero.
• La idea es que con cada corrida de un programa, la semilla cambie.
• Lo único que sabemos que siempre esta cambiando, es el tiempo,
podemos usarlo en este caso.
• La librería time contiene funciones para conocer y modificar la fecha,
y la hora local:
– La función time devuelve el numero de segundos transcurridos desde las
00:00:00 del primero de Enero de 1970.
• La expresión que permitirá cambiar la semilla de acuerdo al tiempo:
– srand((int) time(NULL));

12/03/2022
Otra Herramienta
• Todo programa que use números aleatorios,
debería modificar la semilla.
• Para usar la expresión srand, se debe conocer:
– El proceso de generación de números aleatorios.
– La existencia de la función time, de la librería time.
• En conclusión, existe una cierta complejidad en
este proceso, que se puede esconder usando un
procedimiento:
– void Randomize(void);
void Randomize(void){
srand((int) time(NULL));
}

12/03/2022
Construcción de una Librería Propia
• Ahora poseemos dos herramientas para trabajar con
números aleatorios.
• Lo ideal aquí es crear nuestra propia librería.
• Las librerías que crearemos, son archivos de extensión .lib
• Para lograrlo se deben seguir ciertos pasos:
– Crear un proyecto, de tipo Librería estática
– Añadir al proyecto un archivo de cabecera (para la interfase).
Aquí se añadirán:
• Prototipos
• Declaraciones de constantes
• Nuevos tipos de datos
– Añadir al proyecto un archivo .c que contendrá la
implementación de las herramientas declaradas en la interfase.
– Al terminar, se creará un archivo de extensión .lib, que será
nuestra nueva librería.

12/03/2022
Crear El Proyecto
Vamos a crear una
librería estática

12/03/2022
Añadir Los Archivos
Añadimos el archivo de
cabecera(la interfase)
de ext. *.h
Falta añadir el
archivo *.c, para
la
implementacion
El archivo *.c
Ahora ya estan
incluidos todos los
archivos de nuestro
paquete y podemos
continuar
Continuar, el resto de
pasos, son los
mismos para crear un
proyecto normal
Aquí ya aparecerá
elegida la opción de
librería estática, no se
debe cambiar
Nuestra librería se
llamará random.lib y
aquí se indica el
directorio donde se
creará

12/03/2022
¿Cómo Crear La Interfase?
• La interfase, es, como ya sabemos, la cara que una librería, da a un
cliente.
• En una interfase se pueden incluir:
– Prototipos de funciones
– Declaraciones de constantes (usando #define)
– Declaraciones de nuevos tipos de datos (veremos como más adelante)
• Esto quiere decir que jamás se incluirá implementación en una
interfase.
• El formato general de una interfase es:
#ifndef _nombre_h
#define _nombre_h
/*Líneas de #include para librerías que se vaya a usar*/
/*prototipos de funciones*/
/*definición de constantes*/
/*declaraciones de nuevos tipos de datos*/
#endif
El nombre de la
librería
En programas complejos, una
interfase puede ser incluida en
varios archivos .c, para evitar
“confusiones” se pregunta si la
intefase no ha sido usada aun
(ifndef: if not defined)
Si no ha sido usada, se define,
caso contrario, se ignoran todas las
declaraciones de la misma

12/03/2022
Nuestra Nueva Interfase

12/03/2022
La Implementación
Se debe incluir la
interfase, random.h
Al incluirla, asegúrese
de encerrarla entre “”,
y no entre <>
Si al
compilar(Compile-
Make), todo tuvo
éxito, estamos listos
para usar nuestra
librería

12/03/2022
Un Programa Cliente
• Ahora podemos ponernos del lado del cliente,
como hace para usar esta nueva librería?
• Nuestro nuevo programa usara la librería para
simular el lanzamiento de 10 dados.
Al crear el nuevo
proyecto, como cliente,
se añade la nueva
librería, con su ruta
completa. Para evitar
esto, la solucion es
copiar random.lib en el
directorio lib del
compilador
Al incluir la interfase,
también debe indicarse
la ruta completa. Esto
siempre y cuando el
archivo .h se encuentre
en un directorio
diferente del directorio
de trabajo o del
directorio include del
compilador

12/03/2022
Evaluación de una Interfase
• Ahora podemos evaluar nuestra interfase, usando los criterios
mencionados al comienzo:
– Unificada: las herramientas de la interfase comparten un tema en
común: los números aleatorios, por lo tanto, si es unificada.
– Simple: no le hemos usado mucho, pero con el programa cliente
podemos darnos una idea de que en realidad esconde la complejidad
correctamente y las herramientas son muy fáciles de usar.
– Suficiente: realmente las herramientas no cubren todo lo que un cliente
pueda desear hacer con los números aleatorios. Aun le falta por
desarrollar.
– General: las herramientas disponibles son bastante generales, en el
sentido de que no están limitadas a un solo tipo de cliente.
• Este seria el caso, si la interfase solo incluyera funciones para simular que un
dado es lanzado, o para simular que una carta es escogida.
• En cambio la interfase provee las herramientas para desarrollar cualquiera de
esas funciones
– Estable: si la interfase satisface los requerimientos anteriores,
probablemente podrá permanecer estable por un buen tiempo

12/03/2022
Programación modular
Unidad 4
Final de la unidad
Y del curso…. !Muchas gracias
a todos!

ALP Unidad 4: Programación modular

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a ALP Unidad 4: Programación modular

Similar a ALP Unidad 4: Programación modular (20)

Más de Franklin Parrales Bravo

Más de Franklin Parrales Bravo (20)

ALP Unidad 4: Programación modular