Programación Estructurada

Práctica No. 8
Funciones de usuario.

Objetivo
Al concluir la práctica el alumno comprenderá como hacer uso de las funciones matemáticas que
están incluidas en el compilador y las aplicará en la construcción de programas.

Introducción teórica
Una función es un miniprograma dentro de un programa. Las funciones contienen varias sentencias
bajo un solo nombre que un programa puede utilizar una o más veces para ejecutar dichas sentencias.
Las funciones ahorran espacio, reduciendo repeticiones y haciendo más fácil la programación,
proporcionando un medio de dividir un proyecto grande en módulos pequeños más manejables.

Concepto de función
C y C++ fue diseñado como un lenguaje de programación estructurado, también llamado
programación modular. Por esta razón, para escribir un programa se divide éste en varios módulos,
en lugar de uno sólo largo. El programa se divide en muchos módulos (rutinas pequeñas denominadas
funciones), que producen muchos beneficios:
• Aislar mejor los problemas.
• Escribir programas correctos más rápidos.
• Producir programas más fáciles de mantener.

void main( )
{
obtenercaracteres();
alfabetizar();
verletras();
}

Funciones generadas por el usuario

Una función es, un conjunto de sentencias que se pueden llamar desde cualquier parte de un programa.
Las funciones permiten al programador un grado de abstracción en la resolución e un problema.
Las funciones en C y C++ no se pueden anidar. Esto significa que una función no se puede declarar
dentro de otra función. La razón para esto es permitir un acceso muy eficiente a los datos. En C y
C++ todas las funciones son externas o globales, es decir, pueden ser llamadas desde cualquier punto
del programa.

La estructura de un función en C se muestra a continuación:

Tipo_de_Retorno Nombre_de_Función (Lista_de_Argumentos)
{
cuerpo de la función
Return expresión
}
Tipo_de_Retorno: Tipo de valor devuelto por la función o la palabra void si la función no devuelve
ningún valor.
Nombre_de_Función: Nombre que el usuario le asigna a la función.
Lista_de_Argumentos: Lita de declaración de los parámetros de la función separados por comas.

Argumentos y parámetros formales

float suma(float num1, flota num2)

{
float resp;
resp = num1 + num2;
return resp;
}
Los aspectos más sobresalientes en el diseño de una función son:
• Tipo de Retorno: Es el tipo de dato que devuelve la función y aparece antes del nombre de la función.
• Lista de Argumentos: Es una lista de argumentos tipificados que utilizan el siguiente formato:
tipo_de_dato argumento1, tipo_de_dato argumento2, . . .

1. Cuerpo de la función: Se encierra entre par de llaves ({ }). No hay punto y coma después de la
llave de cierre.
2. Paso de parámetros: Posteriormente se verá que el paso de parámetros puede ser por valor y por
referencia.
3. No se pueden declarar funciones anidadas.
4. Declaración local: Las constantes, tipos de datos y variables declaradas dentro de la función son
locales a la misma y no perduran fuera de ella.
5. Valor devuelto por la función: Mediante la palabra reservada return se devuelve el valor de la
función.

Funciones con y sin argumentos

Nombre de la función
Nombre de la función: El nombre de una función comienza con una letra y puede contener N cantidad
de letras, guión bajo (_), o números que desee. El compilador es sensible a mayúsculas, lo que
significa que as letras mayúsculas y minúsculas son distintas a efectos del nombre dela función.

void saludo(void);
void producto(int, int);
int max(int x, int y);
double media(double x1, double x2);
doublé MAX(int *m, int n);

Tipo de dato de retorno

Si la función no devuelve un valor int, se debe especificar el tipo de valor devuelto (de retorno) por
la función; cuando devuelve un valor int, se puede omitir ya que por defecto C y C++ asume que
todas las funciones son enteras, a pesar de ello siempre conviene especificar el tipo aun siendo int,
para mejor legibilidad. El tipo debe ser uno de los tipos simples de C y C++, tales como int, char o
float, o un puntero a cualquier tipo C y C++, o un tipo struct.

int max(int x, int y) /*Devuelve un tipo int*/

double media(double x1, double x2) /*Devuelve un tipo double*/
float fun1 (float a, float b) /*Devuelve un tipo float*/
char num_car(char *cadena) /*Devuelve un puntero a char*/

Si una función no devuelve un resultado, se puede utilizar el tipo void, que se considera como un tipo
de dato especial. Una función que no devuelve un resultado, a veces se denomina procedimiento. Para
indicar al compilador que una función no devuelve resultado, se utiliza el tipo de retorno void.

void imprime(void)
void resultados(int a, int b, int c)

/*Ejemplo 1*/
#include <stdio.h>
#include<stdlib.h>
#include<conio.h>

int saludo(void); //F.P.

int main()
{
printf("Ejecucion de la funcion saludo\n\n");
saludo();
getchar( );
return 0;
}
int saludo(void)
{
printf("Bienvenido a C!!!");
printf("\n");
}
Salida en pantalla:

/*Ejemplo 2*/
#include <stdio.h>
#include<stdlib.h>

int suma(int, int); //F.P.

int main()
{
int dato1,dato2;
printf("Primer valor: ");
scanf(“%d”,&dato1);
printf("Segundo valor: ");
scanf(“%d”,&dato2);
suma(dato1,dato2);
getchar( );
return 0;
}
int suma(int x, int y) //Definición de F.P.
{
int z;
z = x + y;
printf(“%d + %d=%d”,x,y,z);
printf("\n");
}
Salida en pantalla:

Funciones que regresan valores

Una función puede devolver un único valor. El resultado se muestra con una sentencia return. El
valor devuelto puede ser considerado tipo de dato excepto una función o un arreglo. Se puede
devolver valores múltiples devolviendo un puntero o una estructura. El valor de retorno debe de seguir
las misma reglas que se aplican a un operador de asignación. Una llamada a la función produce la
ejecución de las sentencias del cuerpo de la función y un retorno a la unidad de programa llamadora
después que la ejecución de la función se ha terminado, normalmente cuando se encuentra una
sentencia return.

/*Ejemplo 3*/
#include <stdio.h>
#include<stdlib.h>
int suma(int, int); //F.P.
int main()
{
int dato1,dato2,r;
printf("Primer valor: ");
scanf(“%d”,&dato1);
printf("Segundo valor: ");
scanf(“%d”,&dato2);
r = suma(dato1,dato2);
printf(“%d + %d=%d”,dato1,dato2,r);
printf("\n");
getchar( );
}
int suma(int x, int y)
{
int z;
z = x + y;
return z;
}
Salida en pantalla:
/*Ejemplo 4*/
#include <stdio.h>
#include<stdlib.h>
int potencia(int, int); //F.P.
int main()
{
int b,e,r;
printf("Teclea el valor de la base: ");
scanf(“%d”,&b);
printf("Teclea el valor de la potencia: ");
scanf8”5d”,&e);
r = potencia(b,e);
prinf(“%d a la %e es =%d”,b,e,r);
printf"\n");
getchar( );
return 0;
}
int potencia(int base, int exponente)
{
int z=1, i;
for(i = 1; i <= exponente; i++)
{
z *= base;
}
return z;
}
Salida en pantalla:

Funciones que no son prototipo:

/*Ejemplo 5 Programa que permite leer el valor correspondiente a una distancia en millas y las
visualice expresada en metros, sabiendo que 1 milla equivale a 1609.34 metros*/

/*Ejemplo 5 */
#include<stdio.h>
#include<stdlib.h>
 float distancia(float a, float b) //La función no prototipo no lleva punto y coma.
{

float c;
b=1609.34;
c=a*b;
return c;

}
int main(){

float a,b;
float c;

printf("Ingrese la distancia en millas:");

scanf(“%d”,&a);

printf("La distancia ingresada en millas es: ",distancia(a,b));

printf("\n");

getchar( );

return 0;

}
Salida en pantalla:

/* Ejemplo 6 Ingrese dos números enteros y/o reales y muestre la suma, resta, multiplicación, división
y el modulo.*/

/*Ejemplo 6*/

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int suma(int a, int b, int c){

c=a+b;

return c;
}

int resta(int a, int b, int c){

 c=a-b;

return c;
}

int multiplicacion(int a, int b, int c){

c=a*b;

return c;
}
int division(int a, int b, int c){

c=a/b;

return c;
}

int modulo(int a, int b, int c){

c=a%b;

return c;
}

int main(){

int a,b,c;

printf("Ingrese dos numeros enteros: ");

scanf(“%d %d”,a,b);
printf("La suma es: ",suma(a,b,c));
printf("La diferencia es: ",resta(a,b,c));
printf("La multiplicacion es: ",multiplicacion(a,b,c));
printf("La division es: ",division(a,b,c));
printf("La operacion modulo es: ",modulo(a,b,c));
printf("\n");

getchar( );

return 0;

}
Salida en pantalla:
/*Ejemplo 7 Programa para evaluar la función f(x)=4x^2+3x+5 en un punto x*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int evaluar(int x) //Función no prototipo.

{
x=4*pow(x,2)+3*x+5;

return x;
}

int main(){

int x;

printf("Introduce el punto a evaluar: ");

scanf(%d%,&x);
printf("La funcion: 4*x^2+3*x+5 en el punto x vale:",evaluar(x));
printf("\n");

getchar( );

return 0;

}
Salida en pantalla:

Funciones : Parámetros por valor y por referencia

(Recursividad)
Parámetros por valor y por referencia
Los parámetros de una función se pueden definir de dos maneras: Por valor o por referencia. Hasta
ahora siempre hemos declarado los parámetros de nuestras funciones del mismo modo. Sin embargo,
éste no es el único modo que existe para pasar parámetros.
Paso por valor
Este método copia el valor de los argumentos sobre los parámetros formales, de manera que los
cambios de valor de los parámetros no afectan a las variables utilizadas como argumentos en la
llamada. Lo importante en el paso por valor es el valor del argumento, por eso es indiferente si este
argumento es una variable, una constante o una expresión.
Paso por referencia en C++.
A diferencia del paso por valor, en el paso por referencia los parámetros no copian el valor del
argumento, sino que comparten su valor. Por lo que cuando cambia el valor del parámetro también
cambia el valor de la variable utilizada como argumento en la llamada. La forma de indicar un
parámetro por referencia es anexar el símbolo & al final del nombre de la variable de tipo en la lista
de parámetros formales, tanto en el prototipo de la función como en el encabezado de su definición.

Funciones que llaman a funciones

Un cuerpo de función puede contener una llamada a otra función. La situación en este tipo
de llamadas es exactamente la misma que si la llamada de función se hubiera efectuado en la
función main del programa; la única restricción es que el prototipo debe aparecer antes de
que se emplee la función.
Recursividad
Una función recursiva es aquella que se llama a sí misma. Esto se traduce en que dentro del código
de un subprograma recursivo hay una sentencia o expresión donde aparece la llamada a la misma
función. Para no crear secuencias de infinitas llamadas (ya que la función llamada, volverá a llamarse
por ser a su vez recursiva) necesitamos dos elementos:
1. Las funciones recursivas deben tener argumentos, cuyos valores diferencien a una llamada de
otra.
2. Debe existir una condición final o condición de parada, que utiliza la información de los
argumentos para verificar si la recursión debe finalizar, en cuyo caso no se producen más llamadas.
Evidentemente la secuencia de valores de los argumentos debe ser tal que se garantice que en algún
momento se llegue a la condición final de la recursión. De no ser así, se producirá un error de
Desbordamiento de Pila (Stack Overflow) que indica que las llamadas recursivas han saturado la
memoria de la pila del programa. La recursividad está directamente relacionada con una técnica de
programación llamada Divide y Vencerás, de tal manera que esta técnica nos puede ayudar a descubrir
la forma que debe tener nuestra función recursiva. Esta técnica se basa en lo siguiente: frente a un
problema, se realizan una serie de tareas básicas que nos llevan a tener el mismo problema pero de
complejidad menor. Si esto lo aplicamos recursivamente, la resolución del problema se traduce en
ejecutar una serie de tareas simples que nos desembocan al final en el mismo problema pero de una
complejidad tan simple que es trivial resolverlo. Esta resolución se hace en la condición final de la
recursión y se denomina Caso Base.
La forma en que hemos declarado y pasado los parámetros de las funciones hasta ahora es la que
normalmente se conoce como "por valor". Esto quiere decir que cuando el control pasa a la función,
los valores de los parámetros en la llamada se copian a "objetos" locales de la función, estos "objetos"
son de hecho los propios parámetros.

/*Ejemplo 8 Paso de parámetros por valor. */

#include <stdio.h>
int funcion(int n, int m); //F.P.
int main() {
 int a, b;
a = 10;
b = 20;
printf(“%d %d “,a,b);
printf("funcion(a,b) ->,funcion(a,b);
printf(“función(10,20)”,función(10,20));

return 0;
}
int funcion(int n, int m) {
n = n + 2;
m = m - 5;
return n+m;
}
Salida en pantalla:

Bien, ¿qué es lo que pasa en este ejemplo?

Empezamos haciendo a = 10 y b = 20, después llamamos a la función "funcion" con las objetos a y b
como parámetros. Dentro de "funcion" esos parámetros se llaman n y m, y sus valores son
modificados. Sin embargo al retornar a main, a y b conservan sus valores originales. ¿Por qué?
La respuesta es que lo que pasamos no son los objetos a y b, sino que copiamos sus valores a los
objetos n y m. Piensa, por ejemplo, en lo que pasa cuando llamamos a la función con parámetros
constantes, es lo que pasa en la segunda llamada a "funcion". Los valores de los parámetros no pueden
cambiar al retornar de "funcion", ya que esos valores son constantes. Si los parámetros por valor no
funcionasen así, no sería posible llamar a una función con valores constantes o literales.

/*Ejemplo 9 Paso de parámetros por referencia. */

#include <stdio.h>
#include<stdlib.h>

int funcion(int &n, int &m);

int main() {
int a, b;

a = 10; b = 20;
printf(“%d %d”,a,b);
printf(“funcion(a,b)->”,funcion(a,b));
printf(“%d %d”,a,b);

/* printf( "funcion(10,20) ->",función(10,20)); // (1)

es ilegal pasar constantes como parámetros cuando
 estos son referencias */

return 0;
}

int funcion(int &n, int &m) {

n = n + 2;
m = m - 5;
return n+m;
}
Salida en pantalla:

En este caso, los objetos "a" y "b" tendrán valores distintos después de llamar a la función. Cualquier
cambio de valor que realicemos en los parámetros dentro de la función, se hará también en los objetos
referenciadas. Esto quiere decir que no podremos llamar a la función con parámetros constantes,
como se indica en (ejemplo 8), ya que aunque es posible definir referencias a constantes, en este
ejemplo, la función tiene como parámetros referencias a objetos variables. Y si bien es posible hacer
un casting implícito de un objeto variable a uno constante, no es posible hacerlo en el sentido inverso.
Un objeto constante no puede tratarse como objeto variable.

Desarrollo Práctico
1. Escriba la función max que imprima el número mayor de tres enteros.
/*Desarrollo Práctico 1*/
#include <stdio.h>
#include <stdlib.h>

int max (int, int, int); //F.P.

int main()
{
int a, b, c;
printf("Teclea los tres valores a comparar: ");
scanf(“%d %d %d”,a,b,c);
max(a,b,c);
getchar( );
}
“Algo falta aquí, qué es?”
{
if (x > y)
{
if(x > z)
printf(“%d es el mayor”);
else
printf(“%d es el mayor”);
}
else
{
if(y > z)
printf(“%d es el mayor”);
else
printf(“%d es el mayor”);
}
}
Nota: Completar el programa.
Salida en pantalla:

2. Escriba una función que calcule la media aritmética de dos números reales.

/*Desarrollo Práctico 2*/

#include <stdio.h>
#include <stdlib.h>

float media (float, float); //F.P.

int main()
{
float x1, x2, m;
printf("Introduce el primer valor:");
scanf(“%d”,&x1);
printf("Introduce el segundo valor:");
scanf(“%d%,&x2);
m = media(x1, x2);
printf("El valor medio es: ",m);
printf("\n");
gethar( );
}
float media(float d1, float d2)
{
“Algo falta aquí, qué es?”
}
Nota: Completar el código.
Salida en pantalla:
3. Escribe un programa en C que con una función calcule el área de un triángulo.
Area=base*altura/2;
La función prototipo puede ser: float área_triangulo(float,float); //F.P.

4. Escribe una función que calcula el cubo de los 10 primero números naturales.
/*Desarrollo Práctico 4*/
#include <stdio.h>
#include <stdlib.h>
int cubo(int); //F.P.
int main( )
{
int i, c;
for(i = 1; i <= 10; i++)
{
c = cubo(i);
printf("El cubo de:%d es %d",i,c);
printf("\n");
}
getchar( );
}
int cubo(int dato)
{
return dato * dato * dato;
}
Salida en pantalla:

Cuestionario
1. Defina que es una función.
2. Para qué sirve la sentencia return
3. ¿Cuál es la ventaja o desventaja de utilizar una función?
4. ¿Cuál sería el prototipo de una función llamada área_circulo que imprima el área de un circulo?
5. ¿Las variables declaradas dentro del cuerpo de una función son visibles a todo el programa?
Conclusiones Individuales.