Funciones

“En C”
Semestre de Otoño 2006

Claudio Gutiérrez-Soto
Aprendizajes Esperados
 Contextualización de las funciones
 Definición de Funciones
Funciones
 Sea C(x) una definición de la complejidad de un
problema x y E(x) una función que define el esfuerzo (en
tiempo) requerido para resolver un problema x. Para dos
problemas, p1 y p2 , si
C(p1) > C(p2) 1.a
se deduce que
E(p1) > E(p2) 1.b
Funciones
Para un caso general, este resultado es
intuitivamente obvio. Se tarda más tiempo en
resolver un problema difícil.

Se ha encontrado otra propiedad interesante, a

partir de la experimentación sobre la resolución
humana de problemas. Se trata de lo siguiente:
C(p1 + p2) > C(p1) + C(p2) 1.c
Funciones
 La ecuación 1.c indica que la complejidad de un
problema compuesto por p1 y p2 es mayor que la
complejidad total cuando se considera cada problema
por separado . Considerando la desigualdad 1.c y la
condición implicada por las desigualdades 1.a y 1.b, se
deduce que :

E(p1+p2) > E(p1) + E(p2) 1.d

Funciones
 Esto nos lleva a una conclusión del tipo “Divide
y Vencerás".
 Por consiguiente deberemos considerar las
funciones como “Cajas Negras", las cuales se
encargaran de ejecutar una tarea especifica.
 Por lo tanto deberemos concentrarnos en el
"Diseño Global de Programa" en lugar de los
detalles.
Funciones
La estructura de una función es como sigue:
tipo_de_funcion nombre_de_la_funcion(argumentos)
{
Cuerpo de la Función
return(variable ó valor); /* opcional sólo cuando la función
es de tipo void*/
}
Funciones
 Donde el tipo_de_funcion corresponde al
tipo de datos que retorna ó devuelve dicha
función, la cual puede ser del tipo entero
( int ) , flotante (float), carácter (char )
Funciones
 argumentos: corresponde a valores recibidos por la
función, los cuales también se deben definir de un tipo
determinado, como si se tratase de una definición de
variable común y corriente, cabe destacar además que
no necesariamente una función debe recibir un valor, si
no que esta puede estar vacía.
La estructura de los argumentos pueden ser:
nombre_de_la_funcion(tipo_dato arg1,tipo_dato
arg2,...,tipo_dato argN)
Funciones
ó también:

nombre_de_la_funcion(arg1, arg2,..., argN)

tipo_dato arg1,tipo_dato arg2,...,tipo_dato argN;
{
Cuerpo de la Función
return(variable ó valor);
}
Ejemplo
 Crear un programa que sume dos valores
utilizando una función llamada suma, la
cual recibe como argumentos de tipo
entero.
Ejemplo
#include<stdio.h>
#include<conio.h>
int suma(int a,int b);
void main()
{
int a,b,result;
clrscr( );
printf("Ingrese el primer valor \n");
scanf("%d",&a);
printf("Ingrese el segundo valor \n");
scanf("%d",&b);
result=suma(a,b); //se ingresan las variables
//adecuadas como parámetros y el valor devuelto
por //la función es asignada a la variable result.
printf("El resultado es : %d \n",result);
}
int suma(int a,int b)
{
return(a+b);
}
Otro Forma
#include<stdio.h>
#include<conio.h>
int suma(int a,int b);
void main()
{
int a,b,result;
clrscr( );
printf("Ingrese el primer valor \n");
scanf("%d",&a);
printf("Ingrese el segundo valor \n");
scanf("%d",&b);
result=suma(a,b);
printf("El resultado es : %d \n",result);
}
int suma(int a,int b)
{
int result;

result=a+b;
return(result);
}
Ejercicio
 Crear un programa que calcule la potencia
utilizando funciones
 Solución
#include<stdio.h> float potencia(int base, int exp)
#include<conio.h> {
float potencia(int base, int exp);
void main( ) int i;
{ float pot;
int a,b; if(exp>=0)
float pot; for(i=1,pot=1.0 ; i<=exp ; i++)
pot=pot*base;
clrscr( );

printf("Ingrese el valor de la base \n"); else{

scanf("%d",&a); for(i=1,pot=1.0 ; i<= (-1*exp) ; i++)
printf("Ingrese el valor del exponente pot=pot*base;
\n");
scanf("%d",&b); pot=1/pot;
pot=potencia(a,b); }
printf("El resultado es: %f \n",pot); return(pot);
} }
Conclusiones
 La idea general es poder resolver el problema
abstrayéndose de la implementación.
 Es mejor dividir el problema, en pequeños
subproblemas y luego resolver dichos
subproblemas. (Dividir para Vencer)
 Las funciones reciben argumentos. Dichos
argumentos se utilizan como variables que sólo
existen en el cuerpo de esa función.
 Las funciones son del tipo, de acuerdo al valor
que retornan.