Departamento de Informática

Universidad Técnica Federico Santa María

Subprogramas

Programación de Computadores
IWI-131-p1
Prof.: Teddy Alfaro Olave

Subprogramas
• Estrategia “divide y conquistarás”
• Un programa puede volverse complejo, esta
complejidad puede ser abordada dividiendo
el programa en subprogramas más pequeños
y más manejables.
• Programación Top-Down. Conociendo
nuestra meta, precedemos a dividir nuestro
problema en tarea concurrentes

1
 Descomponiendo

Program SubPrograma1 Program muy_grande;

muy_grande;
Ejecuta subPrograma1
SubPrograma2 Ejecuta subPrograma2
Programa muy
Ejecuta subPrograma1
largo y
complejo SubPrograma3 Ejecuta subPrograma3

Ejemplo
#include <stdio.h> include <stdio.h>
int max3(int n1, int n2, int n3) {
int main(int argc, char *argv[]) { if (n1>=n2 && n1>=n3)
int num1,num2,num3, max; return n1;
else
printf("ingrese 3 numeros\n"); if(n2>=n1 && n2>=n3)
scanf("%d %d %d",&num1,&num2,&num3); return n2;
else
if (num1>=num2 && num1>=num3) return n3; }
max=num1; int main( ) {
else int num1,num2,num3, max;
if(num2>=num1 && num2>=num3)
max=num2; printf("ingrese 3 numeros\n");
else scanf("%d %d %d",&num1,&num2,&num3);
max=num3;
max=max3(num1,num2,num3);
printf("el maximo es %d\n",max);
printf("el maximo es %d\n",max);
return 0;
} return 0; }

2
 Subprogramas en C
• Existen 2 tipos de subprogramas: Las Funciones
y los Procedimientos.
• Las funciones son un conjuntos de instrucciones
que deben devolver un resultado. En cambio un
procedimiento sólo realiza un conjunto de
instrucciones
• Para C, los procedimientos también los considera
como funciones, solo que devuelven un resultado
tipo void
• Una función es subprograma que representa una
abstracción de una expresión compleja. Su
utilización es similar a la matemática, recibe 0 o
más parámetros, y devuelve un único resultado.

Prototipos de Función
• Todas las funciones deben ser declaradas antes de
ser usadas.
• Este requisito se cumple mediante la utilización
del prototipo
• Prototipo especifica la interfaz de datos de una
función por:
– Tipo que retorna
– El tipo de sus parámetros
– El numero de sus parámetros
• Ejemplo:
int cuadrado(int i); int cuadrado(int);

3
 Los prototipos
• Nos permiten programar abstrayendonos de
funciones que aun no hemos programado
• Además, proveen información para que el
compilador pueda detectar problemas en la
cantidad de paramentros, y en la no
compatibilidad de tipos de datos

Ejemplo con Prototipo

include <stdio.h> include <stdio.h>
int max3(int n1, int n2, int n3) { int max3(int , int , int ) ;
if (n1>=n2 && n1>=n3) int main( ) {
return n1; int num1,num2,num3, max;
else
if(n2>=n1 && n2>=n3) printf("ingrese 3 numeros\n");
return n2; scanf("%d %d %d",&num1,&num2,&num3);
else
return n3; } max=max3(num1,num2,num3);
int main( ) {
int num1,num2,num3, max; printf("el maximo es %d\n",max);

printf("ingrese 3 numeros\n"); return 0; }

scanf("%d %d %d",&num1,&num2,&num3); int max3(int n1, int n2, int n3) {
if (n1>=n2 && n1>=n3)
max=max3(num1,num2,num3); return n1;
else
printf("el maximo es %d\n",max); if(n2>=n1 && n2>=n3)
return n2;
return 0; } else
return n3; }

4
 Formato general
• La forma de declarar funciones es la siguiente. Si se
tratase de un prototipo no tendria cuerpo.

tipo_dato_r Nombre_funcion(tipo_dato1 parametro1,

tipo_dato2 parametro2,
..........
tipo_dato_n parametro_n)
{ cuerpo del subprograma
retornando un resultado de tipo tipo_dato_r
}

Declaración
tipo_dato_r Nombre_funcion(tipo_dato1 parametro1,
.......
tipo_dato_n parametro_n)
{ cuerpo del subprograma
retornando un resultado de tipo tipo_dato_r }
• Nombre_funcion: es el identificar con el cual llamaremos a la
función
• Parámetros: son el conjunto de valores que se necesitan para
hacer el cálculo. Cada parametro tiene su tipo
• Tipo_dato_r: es el tipo de dato del resultado que se espera entre
la función

5
 Ejemplo de fibonacci
#include <stdio.h>
int fibonacci(int n) {
int v1=1,v2=1,i,suma; Toda función termina su
if(n==1||n==2)
return 1;
ejecución cuando
else { encuentra un return (el
for(i=3;i<=n;i++) { primero que encuentre),
suma = v1+v2;
v1=v2; en el cual debe devolver
v2=suma; el tipo de dato acorde al
}
return suma;
declarado que devuelve
} la función
}
int main( ) {
printf("fibonacci(%d) es %d\n",10,fibonacci(10));
return 0;
}

Ejercicio 1
• La función seno puede ser aproximada:

La precisión del en esta serie infinita puede ser ajustada de

acuerdo a n, es decir, mientras mayor sea el n más preciso.
Se pide desarrollar un programa C, que permita calcular
aproximación del seno de un determinado número y un n
dado. Además del resultado de la aproximación, se debe
mostrar el error real al compararla con la función sin( ) de C.
Cree las fuciones potencia y factorial para ayudarse.

6
 Ejercicio 2
• Un número se dice palindrome si al invertir sus
digitos se obtiene el mismo valor. Ejemplo 12321
es un número palíndrome.
12345, no es palíndrome, ya que al invertirlo
queda 54321.
Realizar un programa C que determine si un
número es palíndrome o no por medio de la
creación y uso de una función llamada invierte

Manejos de Variables entre

subprogramas
• Ya sabemos que cada variable tiene
asociado su tipo de dato. Pero además
debemos tener muy claro que existe otra
clasificación: variables globales, variables
locales, y parámetros formales. Esta
última clasificación restringe a una variable
en cuando o no puede ser accesada, y
además su volatilidad (tiempo de vida).

7
#include <algo.h>
Variables Globales
int global_i, global_j,global_k;
Variables Locales
int funcion1(int param1, char param2) De funcion1
{ int l_i,l_j; //cuerpo retornando un entero}

float funcion2(int param1,int param2, int param3) Variable Local

{ char l_i; //cuerpo retornando un decimal} de funcion2

char funcion4( ) Variables Locales

{ char c; int digit; //cuerpo retornando un caracter} De funcion4

void funcion3(char param1) Variable Local

{ flot s; //cuerpo de procedimiento, no retorna nada} De funcion3

int main( ) {
Variables Locales
int i,j; float dec; char letra;
del main
i=funcion1(3,10);
dec=fucion2(i,10,i%2);
letra=funcion4( ); Parametro formal
fucion3(letra);
return 0; } Parametro actual

Variables locales vs globales

• Variables Locales:
– Está declarada dentro de la función y sólo está
disponible durante su ejecución.
– Se crean cuando se entra a una función y se destruyen
cuando se sale.
• Variables globales:
– Se declaran en el programa principal. Pueden ser
utilizados por el programa y los subprogramas
(funciones).
– Existen durante toda la vida del programa.

8
 Parámetro formal vs actual
• Parámetros formales
– Corresponden a la difiniciones de los parámetros de una
función, deben tener su tipo dato y sus nombres
identificadores. Un parámetro formal se comporta
como otra variable local dentro de la función.

• Parámetros actuales
– Estos corresponden a los valores o expresiones con los
cuales es llamada la función. El parámetro formal es
instanciado con el parámetro formal

Retorno de una función

• Una función retorna a la rutina que lo llamo
cuando:
– Se encuentra la llave que cierra la función
– O cuando la sentencia de return es ejecutada
• Puede ser usada con o sin un valor asociado
• Sin embargo, si la función fue declarada como
aquella que retorna un valor de un cierto tipo,
entonces debe retornar un valor.
• Solo funciones declaradas con tipo void pueden
usar el return sin valor

9
 Determinar las salidas
int i,j,k; int main(){
i=0; j=1; k=2;
void p_uno(int p) { p_uno(10);
int i=10,a; printf("p:i %d\n",i);
a=j+k+i; printf("p:j %d\n",j);
printf("a es %d\n",a); k=13-f_uno(3,5);
j= a % p; printf("f:i %d\n", i);
} printf("f:funcion
%d\n",k);
int f_uno(int e1,int e2) {
int n,m; return 0;
i=100; }
return (e1*e2/j); a es 13
} p:i 0
p: j 3
f: i 100
f:funcion 8

Tipos de Funciones
1.- Funciones diseñadas para realizar operaciones
con sus argumentos y devolver un valor basado en
sus cálculos.
2.- Funciones que manipulan información y
devuelven un valor que indica simplemente el
éxito o el fallo de esa manipulación.
3.- Funciones que no tienen valor de vuelta explícito,
es decir, es de tipo procedimiento y no genera un
valor.

10
 Función main()
• Como ya se señaló, es la función principal
en un programa.
• Cuando se utiliza return, el programa
devuelve un código de terminación al
proceso de llamada (Sistema Operativo).
• El valor devuelto puede ser 0 que indica
terminación normal o cualquier otro valor
cuando se produce un error.

Argumentos de las funciones

funcion(param1, param2, param3, param4,....);
• Los argumentos están definidos por los parámetros
formales, y utilizados con los parametros actuales. Es
la manera de entregarle la información al
subprograma.
• Se comportan como variables locales
• El paso de los parámetros puede ser por valor o por
referencia

11
 Paso de Parámetros por Valor
Se pasan valores desde el punto de invocación
hacia la función. El parámetro formal es una
variable local, mientras que el parámetro actual es
una expresión que sustituye el correspondiente
parámetro formal (sustitución por valor). Una vez
finalizada la función se retorna a la siguiente
instrucción de la invocación, sin provocar cambios
en la variables de ambiente ( a excepción de la
modificación directa de variables globales).
int max(int a, int b); k=max(u, v);

Paso de parámetros por

Referencia
Se permite transferir información desde el punto de
invocación hacia la función, y el retorno de resultados
desde la función. Los resultados son entregados por medio
de variables visibles o accesibles, llamados parámetros
formales variables (precedidos por *). Se les llamas
variables por referencia, ya que no se crea un nuevo
espacio para el parámetro formal, sino que se hace una
referencia a la variable actual durante la ejecución del
procedimiento. El parámetro formal en este caso es sólo
una variable muda.

int max(int *a, int *b); k=max(&u, &v);

12
 Ejemplo simple
#include <stdio.h> La función “procedimiento”
que requiere 2 parametros enteros
void procedimiento(int* x, int y) {
(*x)++; El paso del parámetro
y++; y es sólo por valor
printf("%d %d\n",*x,y);
} El paso del parámetro
x es por referencia
int main(){
int a=0,b=0; El primer parámetro es por referencia, se le entrega
procedimiento(&a,b); la dirección con “&a”, y todos los cambios hechos
printf("%d %d\n",a,b); en la variable x serán hechos también en la variable
return 0; a. El parámetro formal x es reemplazado totalmente
} por el parámetro actual a (misma dirección de
memoria), por eso se que x es solo una variable muda

Ejemplo 3
• Desarrollar una función intercambio, que reciva dos numeros
como parametro y los devuelva intercambiados
void intercambio(int *x, int *y){
int temp;
temp=*x;
*x=*y;
*y=temp;
printf(“\n x=%d y=%d temp=%d “,*x,*y,temp);
}
main( ){
int a=1,b=2;
printf("a=%d b=%d\n",a,b);
intercambio (&a,&b);
printf("a=%d b=%d\n",a,b);
return 0;
}

13
 Volviendo al ejemplo 2
void invierte(int* n) {
int tmp;
tmp = *n;
*n=0;
while(tmp>0) {
*n = (*n)*10+tmp%10;
tmp/=10;
}
}
int main( ){
int num;

scanf("%d",&num);
invierte(&num);
printf("invertiendo es %d\n",num);
return 0;
}

Ejercicio, determine las salidas

int i,j,k; int f2(int* u, int* v,int c) {
int k=4;
void p1(int* a, int* b) { *v=(*u)+c;
int aux; return (j+k)>((*u)+(*v) ); }
aux=*a;
010
*a=*b; int main( ){
*b=aux; } i=1; j=0; k=0; 020
p1(&i,&j);
F1 es 2.2361
void p2(int* a, int b) { printf("%d %d %d\n",i,j,k);
if(*a>b) p2(&j,i+k); 221
*a=(*a)-b+j; printf("%d %d %d\n",i,j,k);
225
else k++; i=k+1;
b=b-(*a)/i; } printf("f1 es %f\n",f1(k,i));
printf("%d %d %d\n",i,j,k);
double f1(int x, int y) { if(!(f2(&i,&k,3)))
x*=x; printf("%d %d
y*=y; %d\n",i,j,k);
return sqrt(x + y); } return 0; }

14
 Invocación de funciones
• Recordar que las variables globales pueden ser
accesadas por cualquier función
• Si en una función existe una variable local de
igual nombre que una global, es la variable local
con la que se trabaja
• Normalmente del main invocamos las funciones,
pero cualquier función puede invocar a otra
función que ya ha sido definida, incluso puede
llamarse a si misma (recursividad).

Recursividad
• Función que se llama a si misma. Un objeto se
dice recursivo si está definido en términos de sí
mismo

void diez_veces(int v) {
if(v==10)
return;
else
diez_veces(v+1)
}

15
 Funciones recursivas
A. Número natural:
I. 1 es un número natural
II. El sucesor de un número natural es un número natural
B. La función factorial, para enteros no negativos:
I. 0! = 1
II. Si n>0 entonces n! = n*(n-1)!
C. Máximo común divisor, para enteros positivos.
Mcd(m,n):
I. mcd(m,0) = m
II. Si n>0 entonces mcd(m,n) = mcd(n, m mod n)
D. Números de Fibonacci:
I. Fib( 0 )=1; Fib( 1 ) =1
II. Fib( n ) = Fib( n-1 ) + Fib( n-2 )

Ejemplos
double factorial(int n) { double fibonacci(int n) {
if (n==0) if(n==1 || n==0 )
return 0.0; return 1.0;
else else
return n*factorial(n-1); return fibonacci(n-1)+fibonacci(n-2);
} }

int mcd(int m,n) { main( ){

if n==0 printf("factorial de 6 %f\n",factorial(4) );
return m; printf("mcd 54 18 es %d\n",mcd(54,18) );
else printf("fibonacci 7 es %f\n",fibonacci(7)
return mcd(n,m%n) );
} }

16
 Punteros
• Un puntero es una referencia a una dirección de
memoria (que apunta a una dirección de memoria)
• Se declara como
tipo_dato * nombre_variable;
Se trabaja con dos operadores unarios: * , &
• * retorna el valor de la variable localizada en la
dirección de memoria
• & retorna la dirección de memoria del operando
• Ejemplos
int *num;
scanf(“%d”,&x);

Ejemplo

12 100 b_puntero

100 a
int a; -

.
int *b_puntero;
.
b_puntero=&a; .

130 - valor

17
 Asignando Valores a través de
Punteros
• Los punteros pueden ser usados al lado izquierdo
de las sentencias de asignación
• Ejemplo:
– Asignar un valor a la ubicación apuntada por el puntero
int *ptr;
*ptr=101;
– Incrementar y decrementar en Punteros
(*ptr)++;
Recordar utilizar paréntesis alrededor de las expresiones
punteros.

Argumentos de main()
• El estándar ANSI define dos argumentos de
main(): argc y argv.
• Permite pasar información al programa de C
mediante argumentos de línea de órdenes.
programa argumento1 argumento2 ….

Línea de órdenes

• argc : contiene el número de argumentos, y es

entero.
• argv : es un puntero a un arreglo de caracteres.

18
 Ejemplo 4
#include <stdio.h>

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

if(argc!=2){
printf(“Ha olvidado escribir su nombre\n”);
return 1;
}
printf(“Hola %s”,argv[1]);
return 0;
}

>>programa Alumno
Hola Alumno
>>programa
Ha olvidado escribir su nombre

19