3.1. - Funciones

Captulo 5.
Funciones
Universidad del Pas Vasco / Euskal Herriko Unibertsitatea 117 Funciones
ndice del captulo
1. Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
2. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
3. Estructura de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

3.1. Declaracin de prototipos . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.2. El cuerpo de la funcin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.3. Variables locales y externas . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.3.1. Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.3.2. Variables externas . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
4. Transmisin de informacin entre funciones . . . . . . . . . . . . . . . 126

4.1. Argumentos de las funciones . . . . . . . . . . . . . . . . . . . . . . . . 126
4.1.1. Las constantes como argumento . . . . . . . . . . . . . . . . 126
4.1.2. Las variables como argumento . . . . . . . . . . . . . . . . . 127
4.2. Valor dado por una funcin: La sentencia return . . . . . . . . 129
4.3. Punteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.4. Utilizacin de los punteros para pasar datos
entre funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
5. Caractersticas de las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

5.1. Duracin: Fijas Vs. Automticas . . . . . . . . . . . . . . . . . . . . . 136
5.2. Ambito de aplicacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
5.3. Modos de guardar variables . . . . . . . . . . . . . . . . . . . . . . . . . 136
5.3.1. Variables Extern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
5.3.2. Variables Static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
5.3.3. Variables Static Extern . . . . . . . . . . . . . . . . . . . . . . . . 137
5.3.4. Variables Auto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.3.5. Variables Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
6. Ejemplo: calcular el valor de la funcin coseno . . . . . . . . . . . . . 139
7. Bibliografa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
8. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

1. Introduccin
Como en otros lenguajes de alto nivel, el C tambin nos ofrece la posibilidad de escribir funciones (sub-
programas). Dependiendo del tipo de lenguaje utilizado, los subprogramas reciben diferentes nombres:
procedimiento, funcin, rutina, subrutina, etc.
El lenguaje C se dise con el objetivo de facilitar la resolucin de programas complejos mediante la uti-
lizacin de funciones. Dividiendo los problemas complejos en problemas ms sencillos, y resolviendo
cada uno de ellos mediante una funcin adecuada, somos capaces de resolver el problema general
(siguiendo la estrategia de divide and conquer). Como ya sabemos esta tcnica es la base de la programa-
cin estructurada y, hoy en da, prcticamente todos los programas se escriben as.
Empezaremos a examinar el concepto de funcin mediante un ejemplo. Supongamos que queremos

hacer un programa para visualizar lo siguiente en pantalla:
************************************************************************
ETSII y de IT
Alameda Urquijo, sin num.
Bilbao
************************************************************************
Para empezar escribiremos este programa sin utilizar funciones:
#include <stdio.h>
#include <conio.h>
#define NOMBRE ETSII y de IT

#define DIRECCION Alameda Urquijo, sin num.
#define CIUDAD Bilbao
#define ASTE_CANT 40
void main ()
{
int cont = 0;
for (cont = 1; cont <= ASTE_CANT; cont ++)
{
putchar (*);
}
putchar (\n);
printf ( %s\n, NOMBRE);

printf ( %s\n, DIRECCION);
printf ( %s\n, CIUDAD);

{
putchar (*);
}
putchar (\n);
}
Como puede verse, en este programa una parte del cdigo est repetida dos veces. Adems el objetivo de
esta parte del cdigo es la misma en los dos casos. Cmo podramos hacer para no escribir dos veces la
misma cosa? La utilizacin de funciones nos da la respuesta a esta pregunta.
Vamos a escribir ahora el mismo programa pero en este caso utilizando las funciones:
#include <stdio.h>
#include <conio.h>
#define NOMBRE ETSII y de IT

#define DIRECCION Alameda Urquijo, sin num.
#define CIUDAD Bilbao
/* Declaracin de prototipos */
void asteriscos (void);
void main (void)

{
asteriscos ();
printf ( %s\n, NOMBRE);

printf ( %s\n, DIRECCION);
printf ( %s\n, CIUDAD);
asteriscos ();
}
Tal y como puede apreciarse, en este programa llamamos dos veces a la funcin asteriscos () . Cada vez
que la llamamos se ejecuta el cdigo escrito dentro de la funcin. A continuacin veamos como se hara
la definicin de la funcin asteriscos () .
#include <stdio.h>
#define ASTE_CANT 40
void asteriscos (void)

{
int cont = 0;

{
putchar (*);
}
putchar (\n);
}
2. Objetivos
El objetivo de este captulo es iniciarse en la utilizacin de funciones en nuestros programas. En concreto

deberemos ser capaces de disear programas que resuelvan tareas concretas mediante el uso de las fun-
ciones adecuadas. Por lo tanto, estos son los objetivos que se pretenden conseguir:
Conocer la sintaxis de las funciones

Aprender a realizar programas utilizando funciones
Conocer los diversos tipos de variables y su mbito de aplicacin en las funciones
Estudiar el paso de parmetros a funciones: constantes, variables, utilizacin de punteros
Realizacin de ejemplos de programacin mediante el uso de funciones.
3. Estructura de las funciones
Como puede verse en el programa anterior, el uso de la funciones comienza con la declaracin de todas
las funciones que se utilizan en el programa. Para ello se debe escribir el prototipo de cada funcin.
Luego se escribe el programa principal y a continuacin las funciones que se utilizan en el programa. Por
lo tanto se distinguen tres secciones, declaracin de funciones o declaracin de prototipos, programa
principal y las llamadas a funciones que este realiza, y por ltimo las funciones, esto es: el cdigo corres-
pondiente a cada funcin. Hay que tener en cuenta que dentro de una funcin pueden existir tambin
llamadas a otras funciones.
3.1. Declaracin de prototipos
Todos los prototipos de funciones utilizadas por el programa se declaran antes de que d comienzo el
programa principal, es decir: antes de escribir la funcin main . De esta manera el compilador reconoce
qu tipo de funcin es, qu tipo de datos da, cuantos parmetros recoge y cuales son sus tipos de datos.
En el ejemplo anterior se procede as:
void asteriscos (void)
El primer void expresa que esta funcin no da como resultado de su ejecucin ningn valor. Luego viene
el nombre de la funcin. El segundo void expresa que esta funcin no toma argumentos. Ms adelante
veremos de qu manera da un valor una funcin y cmo se le pasa parmetros.
3.2. El cuerpo de la funcin
La definicin de la funcin contina con el cuerpo de la funcin. Escribimos las sentencias necesarias
para conseguir el objetivo de la funcin. Antes de empezar a escribir el cdigo de la funcin, debemos
mostrar de qu tipo de funcin se trata y si no se ajusta a lo declarado en el prototipo, al encontrar el
compilador esa diferencia dir que esas declaraciones no estn de acuerdo. Es por ello que lo que hemos
escrito en la primera lnea y en la declaracin de prototipos son iguales: void asteriscos (void) . Este
ejemplo es muy sencillo pero pensamos que es interesante como punto de partida. En secciones poste-
riores concretaremos el uso de las funciones.
3.3. Variables locales y externas
3.3.1. Variables locales
Como hemos visto en el ejemplo anterior hemos definido dentro de la funcin la variable cont. Si escri-
bisemos la siguiente sentencia en la funcin main :
printf (%d, cont);
el compilador dira que hay un error. Por qu? porque las variables definidas dentro de una funcin slo
son reconocidas dentro de esa funcin. Estas variables se denominan locales. Tambin se dice que estas
variables son automticas ya que se crean al hacer la llamada a la funcin y al finalizar la funcin desa-
parecen automticamente.
3.3.2. Variables externas
En ocasiones nos resulta conveniente definir variables que sean conocidas por todas las funciones. Estas
variables se denominan variables externas y se deben declarar antes de main o de todas las funciones.
Para poder hacer una interpretacin sencilla de los programas, las variables externas deben ser usadas lo
mnimo posible.
En el siguiente ejemplo se muestra cmo se utilizan las variables externas. El objetivo del ejemplo es ave-
riguar si un nmero es par y negativo. Para ello se utiliza la variable externa numero. Por lo tanto esta
variable es conocida tanto en el programa principal como en las funciones.
#include <stdio.h>
/* declaracin de prototipos */
void par_si_no (void);

void negativo (void);
/*Variable externa */
int numero;
void main ()
{
printf (Introduce el nmero: );
scanf (%d, &numero);
par_si_no ();
negativo ();
}
void par_si_no ()
{
if ((numero % 2) = = 0)
{
printf (El nmero es par \n);
}
else
{
printf (El nmero es impar \n);
}
}
void negativo (void)

{
if (numero < 0)
{
printf (El nmero es negativo \n);
}
else
{
printf (El nmero es positivo \n);
}
}
4. Transmisin de informacin entre funciones
4.1. Argumentos de las funciones
4.1.1. Las constantes como argumento
Supongamos que, tal y como mostramos a continuacin, queremos hacer un programa para visualizar
en pantalla la evaluacin de unos estudiantes
Juan
Marta
Pedro
Chapas
A continuacin se muestra el programa que consigue este objetivo:
#include <stdio.h>
void linea (int);
void main ()
{
printf (Juan \t);
linea (27);
printf (Marta \t);

linea (10);
printf (Pedro \t);

linea (20);
printf (Chapas \t);

linea (35);
}
void linea (int puntos)
{
int j;
for (j = 1; j <= puntos; j++)

{
printf (-);
}
printf (\n);
}
Cmo le pasamos valores a la funcin lnea encargada de dibujar la evaluacin del alumno?
Al definir una funcin la declaramos as: void linea (int puntos). Cuando se llama a la funcin la variable pun -
tos toma el valor entre parntesis de la llamada de la funcin (linea (10), por ejemplo), y utiliza ese valor en la
ejecucin de la funcin. En este caso la variable puntos toma el valor 10 al hacerse la primera llamada de la
funcin y ese es el valor que utiliza dentro de la funcin.
4.1.2. Las variables como argumento
En este caso queremos obtener el mismo resultado pero la puntuacin de cada estudiante la tomaremos
del teclado siendo por tanto desconocida. Por lo tanto, en este caso no sabremos a priori cul es el
nmero que deberemos utilizar para dibujar la lnea. Cmo hacerlo? La informacin que le damos a la
funcin no es constante como en el caso anterior. Ahora, como puede observarse, se le pasa la variable
en la llamada a la funcin linea (datos), donde datos es la variable que contiene la informacin intro-
ducida mediante el teclado.
void main ()
{
int datos;
printf (Introduce los datos: \n );

scanf (%d, & datos);
linea (datos);
}
main ( )
{ void linea (int puntos)
{
----- ------
-----
linea (datos) -------
------
----- -------
-----
} }
Al hacer la llamada a la funcin, la variable datos toma el valor que tiene y de este modo se lo pasa a la
funcin linea. Dentro de esta funcin la variable puntos toma el valor pasado y las instrucciones del
cuerpo de la funcin utilizan ese valor.
En este caso se pasa tan solo una nica variable como argumento. Pero, como puede verse en el siguiente
ejemplo, tambin es posible pasar ms de una variable.
En este ejemplo dibujaremos una lnea mediante los caracteres introducidos desde el teclado. La longi-
tud de la lnea tambin ser un dato que pasaremos a la funcin. Para ello escribimos una funcin
dibuja que toma dos parmetros: el carcter y la longitud.
#include <stdio.h>
void dibuja (char, int);

void main ()
{
int longitud =1;
char carac;
printf (Introduce el carcter que desees utilizar: \n)

scanf (%c, &carac);
printf (Introduce la longitud de la lnea: \n)

scanf (%d, &longitud);
dibuja (carac, longitud);

}
void dibuja (char mi_ carac, int mi_longitud)

{
int j;
for (j = 1; j <= mi_longitud; j++)
{
printf (%c, mi_carac);
}
printf (\n);
}
main ( )
void dibuja (char mi_carac, int mi_longitud)
{
{
-----
------
-----
-------
dibuja (carac, longitud)
------
-----
-------
-----
}
}
4.2. Valor dado por una funcin: La sentencia return
Como ya sabemos, las funciones dan resultados tomando un valor como argumento. Por ejemplo, la
funcin coseno cuando toma el valor 0 devuelve 1 (cos (0)=1).Cmo se realiza esto en lenguaje C?.
Las funciones dan como resultado de su ejecucin un valor mediante el uso de la sentencia return:
1. Primeramente , cuando se ejecuta return, el control del programa va al programa que ha lla-
mado a la funcin.
2. Posteriormente se evala la expresin entre parntesis que va despus de return, cuyo valor se
pasa como valor de la funcin.
La sentencia return puede ir en cualquier lugar de la funcin y tambin puede haber ms de una.
Supongamos que queremos escribir una funcin que calcula el logaritmo de un nmero. Para ello escri-
biremos un programa principal que pida el nmero y la base, luego llamaremos a la funcin logaritmo y
el programa principal visualizar el resultado.
#include <stdio.h>
#include <math.h>
double logaritmo (float numero, int base);
void main (void)

{
float num;
int base;
printf (INTRODUCE EL NMERO -> );

scanf (%f, &num);
printf (INTRODUCE LA BASE -> );

scanf (%f, &base);
printf (El logaritmo del nmero es este: %lf, logaritmo(num, base));
}
double logaritmo (float numero, int base)

{
double log_valor;
log_valor = log (numero) / log (base);
return (log_valor);
}
Veamos otro ejemplo de utilizacin de funciones que devuelven un valor. Vamos a escribir un programa
que calcule el valor de la serie 1 + 22 + 33 + 44 + ...... + nn
#include <stdio.h>
#include <math.h>
long potencia (int num);
void main (void)

{
int limite, contador;
long resultado = 0;
clrscr ();
printf (Introduce el valor del lmite: );
scanf (%d, &limite);
for (contador = 1; contador <= limite; contador ++)

{
resultado += potencia (contador);
}
printf (\n El resultado es %d: , resultado);

}
long potencia (int num)

{
int cont;
long valor ;
for (cont = 1, valor = 1; cont <= num; cont ++)

{
valor *= num;
}
return (valor);
}
4.3. Punteros
Los punteros (en ingls pointer) expresan la direccin de una variable en la memoria. Para expresar la
direccin de una variable se utiliza el carcter &. Por lo tanto, si el nombre de la variable es puf , &puf
es el puntero de puf y tiene la direccin de puf. Claro que como ya sabemos, la direccin de una varia-
ble es un nmero constante y por lo tanto podemos decir que &puf es un puntero constante.
Pero en C tambin es posible definir variables puntero. Del mismo modo que una variable que tenga un
tipo de datos char, la cual toma un carcter como su valor, as una variable puntero toma como su valor
una direccin.
ptr = &puf; /* asigna a la variable puntero ptr la direccin de la variable puf */
Al hacer esto se dice que el puntero ptr es el puntero de la variable puf.
Pero cmo se declaran los punteros? En los ejemplos siguientes se declaran diversas variables tipo puntero:
int *i_ptr; fi variable puntero que admite direcciones de tipos de datos int, es decir, direcciones
de nmeros enteros.
char *c_ptr; fi variable puntero que admite direcciones de tipos de datos char, es decir, direccio-
nes de caracteres.
float *f_ptr; fi variable puntero que admite direcciones de tipos de datos float, es decir, direccio-
nes de nmeros reales.
Para declarar punteros, por lo tanto, es preciso declarar el tipo de dato del puntero:
int * i_ptr
tipo de dato la variable es puntero nombre de la variable

puntero de nmeros enteros puntero
el operador * (indireccin)
Como ya sabemos si ptr es una variable puntero su contenido ser una direccin. Mediante el operador *,
esto es *ptr, se consigue el valor contenido en esa direccin. En el ejemplo, se define una variable entera
denominada fermin y una variable puntero denominada fermin_ptr. Como se ve cada una de ellas tiene
asignada una direccin en memoria (fermin se encuentra en la 1000 y fermin_ptr en la 1004). Al realizar la
instruccin fermin = 22; el contenido de la direccin 1000 pasa a ser 22. Al realizar la asignacin fer -
min_ptr= &fermin; hacemos que la variable puntero fermin_ptr contenga la direccin de la variable fermin.
Por ltimo, al ejecutarse la instruccin valor = *fermn_ptr; el uso del operador indireccin posibilita el
recoger el valor almacenado en la direccin 1000 (que es el contenido de la variable fermin_ptr), en la
variable valor.
Ejemplo:
Nombre Direc. Cont.
int fermin;
fermin 1000 22
int *fermin_ptr; 1001
1002
fermin = 22; 1003
fermin_ptr 1004 1000
1005
fermin_ptr = &fermin; 1006
1007
valor 1008 22
valor = *fermin_ptr;
Es decir, al ejecutarse la sentencia valor = *fermin_ptr hacemos que se introduzca en la variable valor el
valor contenido en la posicin 1000, por consiguiente la variable valor toma el valor 22.
4.4. Utilizacin de los punteros para pasar datos entre funciones
La utilizacin de funciones debe permitirnos conseguir ms de un objetivo, en cuanto a la consecucin

de valores o tareas. Sin embargo, hemos visto que el uso de la sentencia return nos posibilita que una
funcin nos d un valor pero no ms. La utilizacin de punteros amplia esta posibilidad y de esta forma
una funcin nos puede dar todos los valores que consideremos necesarios. A lo largo de esta seccin exa-
minaremos cmo mediante el uso de punteros podemos pasar informacin entre funciones.
Supongamos que queremos crear un programa que reemplaza los contenidos de dos variables. Para ello
queremos definir una funcin. Esta funcin tomar como argumento estas dos variables y, despus de
ejecutarse, los contenidos de estas dos variables quedarn intercambiados.
#include <stdio.h>
void cambiar_valores (int *x_ptr, int *y_ptr);
void main ()
{
int x = 5, y = 10;
printf (Al principio x = %d e y = %d. \n, x, y);
cambiar_valores (&x, &y);
printf (Al final x = %d e y = %d. \n, x, y);

}
void cambiar_valores (int *x_ptr, int *y_ptr)

{
int elmio;
elmio = *x_ptr;
*x_ptr = *y_ptr;
*y_ptr = elmio;
}
A continuacin examinaremos el funcionamiento del programa. Cuando empezamos a ejecutar el pro-

grama principal la primera sentencia que encontramos es la declaracin de las variables x e y. Por lo
tanto se reserva en la memoria el sitio necesario para guardar esas dos variables. Supongamos por ejem-
plo, que la variable x se guarda en la posicin 1010 y la variable y en la posicin 1012. El valor de la
variable x es 5 y el de y es 10.
Nombre Direc. Cont.
x 1010 5
1011
y 1012 10
1013
1014
De modo que,
Direccin de la variable x = 1010

Direccin de la variable y = 1012
&x = 1010
&y = 1012
La siguiente sentencia es: printf (Al principio x = %d e y = %d. \n, x, y);
Despus de ejecutar la sentencia, en pantalla se visualiza lo siguiente:
Al principio x = 5 e y = 10.
A continuacin llamamos a la funcin cambiar_valores de este modo: cambiar_valores (&x, &y); Por lo
tanto los parmetros que toma la funcin cambiar_valores son las direcciones de x y de y.
cambiar_valores (1010, 1012)
Cuando ejecutamos la funcin cambiar_valores se declaran las variables puntero x_ptr e y_ptr . Al ser
x_ptr y y_ptr variables puntero de tipo entero, su contenido debe ser una direccin de nmero entero. A
continuacin se define tambin la variable elmio .
Nombre Direc. Cont.
x 1010 5
1011
y 1012 10
1013
x_ptr 1014 1010
1015
x_ptr = 1010 1016
y_ptr = 1012 1017
el operador * nos da el contenido de una direccin. y_ptr 1018 1012
1019
*x_ptr = 5
1020
*y_ptr = 10 1021
elmio 1022
elmio = *x_ptr; elmio = 5

*x_ptr = *y_ptr; introducir en la direccin 1010 el dato de la direccin 1012
*y_ptr = elmio; introducir en la direccin 1012 el valor de elmio
De modo que despus de terminar la ejecucin de la funcin, la memoria queda de esta manera:
Nombre Direc. Cont.
x 1010 10
1011
y 1012 5
1013
x_ptr 1014 1010
1015
1016
1017
y_ptr 1018 1012
1019
1020
1021
elmio 1022 5
Al volver nuevamente al programa main desaparecen todas las variables creadas durante la ejecucin de
la funcin. Cuando se ejecuta el segundo printf del programa principal, el valor de la variable x es 10 y
el de la variable y es 5. De modo que el resultado de la ejecucin del programa sera el siguiente:
Al principio x = 5 e y = 10.
Al final x = 10 e y = 5.
Ejemplo
Repetiremos el ejemplo del logaritmo pero en este caso utilizando punteros:
#include <stdio.h>
#include <math.h>
void logaritmo (double *numero_ptr, int base);
void main (void)

{
doublenum;
int base;
printf (INTRODUCE EL NMERO -> );

scanf (%lf, &num);
printf (INTRODUCE LA BASE -> );

scanf (%f, &base);
logaritmo (&num, base);

printf (El logaritmo del nmero es: %lf, num);
}
void logaritmo (double *numero_ptr, int base)

{
*numero_ptr = log (*numero_ptr) / log (base);
}
5. Caractersticas de las variables
Aunque en las anteriores secciones hemos examinado las variables que utiliza el lenguaje C y los tipos de
datos correspondientes, todava nos queda por examinar varias caractersticas de las variables. La ms
importantes son la duracin y su mbito de aplicacin (scope). Combinando estas dos caractersticas
el lenguaje C reconoce las diferentes maneras de guardar variables existentes.
5.1. Duracin: Fijas Vs. Automticas
La variable fija se crea al comienzo de un programa y permanece hasta el fin de la ejecucin de un pro-
grama manteniendo reservada su asignacin de memoria hasta la finalizacin del mismo.
La variable automtica en cambio est unida a una funcin o a un bloque en concreto del programa. De
modo que se crea en el momento en que esa funcin o ese bloque comienzan a ejecutarse y al terminar
la ejecucin desaparece.
5.2. mbito de aplicacin
Mediante mbito de aplicacin indicamos el lugar donde una variable es conocida.
5.3. Modos de guardar variables
En el lenguaje C es posible combinar la duracin y el mbito para definir las diferentes maneras de guar-
dar variables, las cuales son fundamentalmete cuatro y se indican mediante las siguientes palabras clave:
extern, static, auto, register.
5.3.1. Variables Extern
Cuando se quiere utilizar una variable externa fuera del mdulo donde est definida, se vuelve a declarar
de nuevo, pero en este caso concretando por delante el indicador exter n. De esta forma, se indica que la
definicin de esta variable se ha hecho en algn otro lugar.
5.3.2. Variables Static
Estas variables tan solo se reconocen en los sitios en los que han sido definidas, pero no desaparecen al
terminar la ejecucin de la funcin. El ordenador mantiene sus valores para que se puedan volver a uti-
lizar si la funcin es llamada de nuevo.
Ejemplo,
void main (void)

{
int cont;
for (cont= 1; cont <= 3; cont++)
{
printf (Aqu hay %d vuelta \n, cont)
test_static ();
}
}
void test_static (void)

{
int muere = 1;
static int vive = 1;
printf (muere = %d y vive = %d, muere++, vive++);
}
La ejecucin de este programa nos dar lo siguiente:
Aqu hay 1 vuelta

Muere = 1 y vive = 1
Aqu hay 1 vuelta
Aqu hay 1 vuelta
En este ejemplo, vive es una variable esttica que es conocida nicamente en el mbito de aplicacin de
la funcin test_static. Sin embargo, el valor que almacena no se borra al terminar la ejecucin de dicha
funcin y es posible utilizar dicho valor en ejecuciones sucesivas de la funcin.
5.3.3. Variables Static Extern
La diferencia entre las variables externas y las variables externas estticas reside en el mbito. Las varia-
bles externas son conocidas para todas las funciones. Las variables externas estticas tan slo se recono-
cen en los ficheros donde estn declaradas.
int num; negro ( )

static int numero; {

main ( ) }
{
rojo ( )
} {
figaro ( )
{ }

}
Fichero a Fichero b
En este ejemplo, suponemos que un fichero guarda las declaraciones y las funciones main () y figaro (). En
otro fichero se encuentran las otras dos funciones negro () y rojo (). La variable num (variable externa) es
conocida en todas las funciones y la variable numero (variable externa esttica) tan solo en las funciones
main y figaro.
5.3.4. Variables Auto
Si en una funcin no se indica de otra manera todas las variables que declaramos son auto, y por lo tanto
no es obligatorio utilizar este indicador. Decimos que estas variables son automticas y se definen de esta
forma en su declaracin. Si se quiere puede utilizarse la palabra clave auto.
5.3.5. Variables Register
Generalmente las variables se guardan en la memoria RAM del ordenador. Podemos pedir para acelerar el pro-
ceso que las variables usadas frecuentemente se guarden en los registros de la CPU en vez de hacerlo en la
memoria. De esta forma puede acelerarse la ejecucin del programa. Tal y como se muestra en el siguiente
ejemplo, para ello se utiliza la palabra clave register:
register int veloz;
A modo de resumen, en la siguiente tabla se muestran las diferentes maneras de guardar variables.
Modo de guardar Palabra clave Duracin mbito
automtico auto voltil local
register register voltil local
esttico static constante local
externo extern constante general

6. Ejemplo: calcular el valor de la funcin coseno
El valor de la funcin coseno, segn Taylor, es el siguiente:
cos (x) = 1 - x2/2! + x4/4! - x6/6! +
Donde x es un ngulo dado en radianes.
Escribir un programa utilizando N sumandos de la secuencia, que calcule cos (x). La cantidad N de
sumandos, ser equivalente al valor del ltimo y a la secuencia se aadirn los elementos necesarios
hasta que el ltimo (en valor absoluto) sea ms pequeo que 0.0005.
/ **************************************************************************************
Descripcin:
Este programa calcula el valor de la funcin coseno segn Taylor.
***********************************************************************************************/
#include <stdio.h>
#include <conio.h>
/ ********************************** Declaracin de prototipos *********************************/

float potencia (float numero, int exponente);
float factorial (int num);
/***********************************************************************************************/
/ **************************** El programa principal comienza aqu *****************************/

void main (void)
{
/*
El valor de cada elemento de la secuencia Taylor se guarda en valor_elemento.
elementos seala cul es el elemento de la serie de Taylor.
signo el signo que corresponde a cada elemento.
*/
float valor_elemento, ngulo, cos;

int elemento, signo;
/* Limpia la pantalla */
clrscr ();
printf (\nINTRODUCE EL ANGULO EN RADIANES -> );

scanf (%f, &angulo);
valor_elemento = 1;
for (elemento = 1, cos = 1; valor_elemento > 0.0005; elemento ++)
{
valor_elemento = potencia (angulo, elemento* 2) /

factorial (elemento * 2);
if (elemento % 2 == 0)
{
signo = 1;
}
else
{
signo = -1;
}
cos += signo * valor_elemento;
}
printf (\nEL VALOR DEL COSENO ES: %.3f, cos);

getch();
}
/ **************************************************************************************
* Nombre de la funcin: potencia *
* *
* Argumentos de entrada *
* nmero: queremos calcular su potencia *
* exponente: lo que su nombre indica *
* Valor de salida *
* Esta funcin mediante return da el valor del nmero
elevado al exponente *
* *
* *
* Descripcin: *
* Esta funcin logra el nmero elevado al exponente *
* *
* *
***********************************************************************************************/
float potencia (float numero, int exponente)

{
int cont;
float potencia;
for (cont = 1, potencia = 1; cont <= exponente; cont ++)

{
potencia *= numero;
}
return (potencia);
}
/ **************************************************************************************
* Nombre de la funcin: factorial *
* *
* *
* Argumentos de entrada *
* nmero: queremos calcular su factorial *
* exponente: lo que su nombre indica *
* Valor de salida *
* Esta funcin mediante return calcula el factorial
del nmero *
* *
* *
* Descripcin: *
* Esta funcin calcula el factorial de un nmero *
* *
***********************************************************************************************/
float factorial (int num)
{
int cont;
float factorial;
for (cont = 1, factorial = 1; cont <= num; cont ++)

{
factorial *= cont;
}
return (factorial);
}
7. Bibliografa
AUTONAKOS, K.C., MANSFIELD, K.C. Programacin Estructurada en C. Ed. Prentice Hall
KERNIGHAN, BW., RITCHIE D.M. The C Programming Language. Ed. Prentice Hall.
PRESS, W.H., TEKOLSKY, S.A., VETTERLING, W.T., FLANNERY, B.P. Numerical Recipes in C. Ed. Cambridge
QUERO, E., LPEZ HERRANZ, J. Programacin en Lenguajes Estructurados. Ed. Paraninfo.
WAITE, M., PRATA, S., MA RT I N , D. Programacin en C. Introduccin y Conceptos Avanzados. Ed. Anaya
Multimedia.
8. Ejercicios propuestos
1. El valor de la funcin coseno, segn Taylor, es el siguiente:
cos (x) = 1 - x2/2! + x4/4! - x6/6! +
Donde x es un ngulo dado en radianes.
Escribir un programa utilizando N sumandos de la secuencia, que calcule cos (x). La cantidad N de
sumandos, ser equivalente al valor del ltimo y a la secuencia se aadirn los elementos necesarios
hasta que el ltimo (en valor absoluto) sea ms pequeo que 0.0005.
Para realizar el programa, escribir dos funciones que calculen nmeros factoriales y hagan potencias.
2. Introducidos mediante el teclado los nmeros enteros A y B, escribir un programa que consiga el
mximo comn denominador (M.C.D.), siendo A B. He aqu el algoritmo de M.C.D. que se imple-
mentar en una funcin.
1. paso: haz DD = A y D = B.
2. paso: Calcula el resto de la divisin entre DD y D.
3. paso: Si el resto no es 0, haciendo DD = D y D = resto, vuelve al segundo paso.
4. paso: Si el resto es 0, el valor de M.C.D. es D.
3. El centro numrico es el nmero que divide en dos la lista de enteros. La suma de los enteros de
ambos lados es igual, y el comienzo de la primera lista es siempre 1.
De todos los enteros el primer centro numrico es el 6, el cual divide las listas (1, 2, 3, 4, 5) y (7, 8),
tal y como puede verse el resultado de la suma en ambas listas es 15 y el comienzo de la primera es
1. El segundo centro numrico es el 35, siendo las listas (1, 2, ..., 34) y (36, 37, .... , 49) y la suma de
cualquiera de ambas 595.
Mediante un programa encontrar los centros nmericos entre 1 y N. Para ello se utilizarn dos
funciones:
Una funcin que probar si un entero es o no un centro numrico.
Una funcin que devuelve la suma de una lista de nmeros.

4. Se deja caer una pelota desde una altura H. La capacidad de hacer rebotes de la pelota se puede expre-
sar mediante un nmero R menor de 1.0. En cada rebote la altura que consigue la pelota es lo conse-
guido previamente multiplicado por R.
El programa nos pide el factor R para los rebotes y la altura de salida. Luego pedir la altura que
pueda conseguirse en cualquier rebote (mayor que cero); ms tarde calcular en qu rebote conse-
guir la pelota la altura establecida. Para ello el programa nos dir si la altura conseguida es menos o
mayor que lo ledo. Junto con esto, nos dir qu altura ha alcanzado la pelota en el ltimo rebote
NOTA: La altura de salida, conociendo el factor de rebote R y la cantidad de rebotes, debe ser escrita
en una funcin que calcule la altura conseguida en un rebote.
5. He aqu una conocida frmula de fsica nuclear para calcular la masa radioactiva que permanece des-
pus de pasados t aos.
M t = m * (1/2) t/h
Donde:
t es tiempo en aos
M t la masa que permanece pasados t aos
m la masa del comienzo
h media de vida, en aos
La media de vida para el istopo de Carbono 14 son 5.700 aos ; si la masa del comienzo es de 300 gra-
mos, dando diversos valores a t (t = 500, 1.000, 1.500, ..., 9.500, t = 10.000) mostrar en una tabla Mt.
Para ello dados diversos valores de t concretar en una funcin el valor de (1/2) t/h.

3.1. - Funciones

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

3.1. - Funciones

Uploaded by

Copyright:

Available Formats

Captulo 5.

ndice del captulo

3. Estructura de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

4. Transmisin de informacin entre funciones . . . . . . . . . . . . . . . 126

5. Caractersticas de las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

6. Ejemplo: calcular el valor de la funcin coseno . . . . . . . . . . . . . 139

8. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Empezaremos a examinar el concepto de funcin mediante un ejemplo. Supongamos que queremos

Para empezar escribiremos este programa sin utilizar funciones:

#define NOMBRE ETSII y de IT

printf ( %s\n, NOMBRE);

for (cont = 1; cont <= ASTE_CANT; cont ++)

#define NOMBRE ETSII y de IT

void asteriscos (void);

void main (void)

printf ( %s\n, NOMBRE);

void asteriscos (void)

for (cont = 1; cont <= ASTE_CANT; cont ++)

El objetivo de este captulo es iniciarse en la utilizacin de funciones en nuestros programas. En concreto

Conocer la sintaxis de las funciones

3. Estructura de las funciones

3.1. Declaracin de prototipos

void asteriscos (void)

3.2. El cuerpo de la funcin

3.3. Variables locales y externas

3.3.1. Variables locales

printf (%d, cont);

3.3.2. Variables externas

void par_si_no (void);

void negativo (void)

4. Transmisin de informacin entre funciones

4.1. Argumentos de las funciones

4.1.1. Las constantes como argumento

A continuacin se muestra el programa que consigue este objetivo:

printf (Marta \t);

printf (Pedro \t);

printf (Chapas \t);

for (j = 1; j <= puntos; j++)

4.1.2. Las variables como argumento

printf (Introduce los datos: \n );

void dibuja (char, int);

printf (Introduce el carcter que desees utilizar: \n)

printf (Introduce la longitud de la lnea: \n)

dibuja (carac, longitud);

void dibuja (char mi_ carac, int mi_longitud)

4.2. Valor dado por una funcin: La sentencia return

double logaritmo (float numero, int base);

void main (void)

printf (INTRODUCE EL NMERO -> );

printf (INTRODUCE LA BASE -> );

double logaritmo (float numero, int base)

log_valor = log (numero) / log (base);

long potencia (int num);

void main (void)

for (contador = 1; contador <= limite; contador ++)

printf (\n El resultado es %d: , resultado);

long potencia (int num)

for (cont = 1, valor = 1; cont <= num; cont ++)

ptr = &puf; /* asigna a la variable puntero ptr la direccin de la variable puf */

Al hacer esto se dice que el puntero ptr es el puntero de la variable puf.

tipo de dato la variable es puntero nombre de la variable

4.4. Utilizacin de los punteros para pasar datos entre funciones

La utilizacin de funciones debe permitirnos conseguir ms de un objetivo, en cuanto a la consecucin

void cambiar_valores (int x_ptr, int y_ptr);

void cambiar_valores (int x_ptr, int y_ptr)

/ ** Declaracin de prototipos */

/ El programa principal comienza aqu */