c++ con ejemplos,para los que estamos empezando

Es muy común encontrar en los programas operaciones que se deben ejecutar un número repetido de veces en períodos más o menos espaciados. Si bien las instrucciones son las mismas, los datos sobre los que operan varían. A nuestro alrededor, encontramos problemas que presentan esas características, por ejemplo: el cálculo de la nota final de los estudiantes de Programación I, se realizará tantas veces como alumnos hayan inscritos en dicha asignatura, el cálculo del salario de los empleados de una empresa, etc. En estos casos la solución que se diseñe para un solo grupo de datos se debe repetir tantas veces como sea necesario (de acuerdo al número de estudiantes y de empleados para los ejemplos anteriores).
Los cálculos simples o la manipulación de pequeños conjuntos de datos se pueden realizar fácilmente a mano, pero las tareas grandes o repetitivas son realizadas con mayor eficacia por una computadora, ya que estas están especialmente preparadas para ello.
Para repetir varias veces un proceso determinado haremos uso de los ciclos repetitivos, a los cuales se les conoce con el nombre de estructura repetitiva, estructura iterativa, lazo o bucle.
(Tomado de Los guiones de clase de Introducción a la Informática. Universidad de El Salvador. Año 2005)
En C, podemos encontrar tres tipos de ciclos:
• Entrada Asegurada (while)
• Ciclo Controlado Por Contador (for)
• Hacer Mientras (do.. while)
Este ultimo, no está lógicamente estructurado, por tanto no haremos mucho hincapié en él.
Conceptos Generales
Funcionamiento de Un Ciclo
Un ciclo, funciona de la siguiente manera: Evalúa una condición de resultar cierta, realiza una acción o bloque de acciones, luego vuelve a evaluar la condición y si nuevamente resulta cierta, realiza la (s) acción (es). Cuando la condición de cómo resultado falso, se sale del ciclo y continúa con la ejecución normal del programa.
Acumulador:
Es una variable, que , como su nombre lo indica se encarga de acumular valores. Esto se vuelve muy útil, por ejemplo, cuando queremos encontrar la suma de los números del 0 al 9, en el acumulador, vamos guardando los valores de dichas cifras. Puede ser tanto real como entera. Su valor inicial, en la mayoría de los casos es cero.
Contador:
Es una variable de tipo entero, que nos ayuda, en el programa a contabilizar el número de ejecuciones de una misma acción, de un grupo de alumnos etc. Un acumulador tiene tres valores distintos:
• Valor Inicial: es el valor con el cual iniciamos nuestro contador. Generalmente es cero. Esta asignación puede hacerse cuando se declara la variable.
• Valor Final: después de la ejecución del ciclo, el valor del contador, será distinto a su valor inicial, este puede ser mayo o menor que el mismo, todo depende si fue una cuenta creciente o decreciente.
• Valor de Cambio: Es el valor Constante, en el cual se irá incrementando nuestro contador, este puede ser positivo o negativo; es decir, si la cuanta se realiza de manera ascendente o descendente.
NOTA: el lector no debe confundirse entre las variables tipo acumulador y tipo contador, estas se diferencian unas de otras en que: los contadores, su valor de cambio es una constante, ya que aumenta y disminuyen en el mismo valor, mientras que los acumuladores su valor de cambio no es constante. Un acumulador necesariamente lo inicializamos con cero (o al menos en la mayoría de los casos). Un contador puede iniciar con cualquier valor.
Bandera:
Las variables tipo bandera son aquellas que sólo admiten dos valores: cierto o falso, true o false, hombre o mujer... etc
Ciclo de Entrada Asegurada
La sintaxis es la siguiente:
while(condición)
Acción;
Funciona de la siguiente manera: primero evalúa la condición, si da como resultado cierta realiza la acción, luego vuelve a evaluar la condición, si su resultado es falso, se sale del ciclo y continúa con la ejecución del programa.
Hay que tener mucho cuidado, cuando trabajamos con ciclos, ya que podemos caer en un ciclo infinito, es decir que nunca se sale de él. Lo cual no es un error de sintaxis sino de lógica. Por lo cual en las acciones debemos siempre colocar algo que haga que se modifique el resultado de la condición, lo cual puede ser una bandera, un contador o un acumulador.
Ejemplo 4.1
Diseñe un Programa que imprima los primeros 10 números.
#include <stdio.h>
#include <conio.h>
main()
{
int i=1; /*Declaramos nuestro contador con su Valor Inicial*/
while(i<=10) /*Mientras i sea menor o igual a 10:*/
{
printf("%dt", i);/*Imprimir el valor de i*/
i+=1;/*Aumentar el contador en 1*/
}
getch();
return 0;
}
Ejemplo 4.2
Se desea conocer el promedio de los números mayores que cero, en una serie de números ingresados por el usuario. De los cuales no se sabe la cantidad, haciendo uso de una bandera, diseñe un programa en el cual el usuario ingrese los números que desee.
#include <stdio.h>
#include <conio.h>
main()
{
int i=0, sum=0, ban=1, n;
float prom;
while(ban==1)
{
printf("Ingrese un n£mero por Favor:n";
scanf("%d", &n);
if(n>0)
{
i=i+1;
sum+=n;
}
printf("Desea Ingresar Otro N£mero? (Si=1 y No=0)n";
scanf("%d", &ban);
}
prom=sum/i;
printf("************************************************************n";
printf("*** El Promedio de los numeros mayores que cero es: %.2f ***n", prom);
printf("************************************************************n";
getch();
return 0;
}
Ejercicio 4.3
En un salón se tienen las notas de 14, alumnos; de los cuales se desea saber cual fue el promedio de todas las notas, cual fue la nota mayor y la nota menor. Así como la cantidad de aprobados en el curso (Para Aprobar la asignatura se requiere de una nota mayor o igual a 6.0)
#include <stdio.h>
#include <conio.h>
main()
{
float suma=0, prom, menor=11, mayor=-1, nota;
int i=1,j=0;
while(i<=14)
{
printf("Ingrese la Nota del alumno %d:n", i);
scanf("%f", &nota);
while(nota<0.00 || nota >10.00)
{
printf("ERROR, la nota debe estar entre 0 y 10n";
scanf("%f", &nota);
}
if(nota>=6.00)
j=j+1;
if(nota>mayor)
mayor=nota;
if(nota<menor)
menor=nota;
i=i+1;
suma=suma+nota;
}
prom=suma/14;
printf("El Promedio es %.2fnn", prom);
printf("El total de Aprobados es %dn", j);
printf("La Mayor nota fue %.2fn", mayor);
printf("%.2f corresponde a la nota menorn", menor);
getch();
return 0;
}
Ciclo Controlado por contador.
En algunas ocasiones, sabemos a ciencia cierta el número de veces que se tiene que repetir una misma acción o bloque de acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la siguiente:
for( valor inicial; condición; incremento)
accion;
Donde:
Valor inicial: es el valor con el cual inicializamos nuestra variable de control.
Condición: si la cumple, ejecuta la acción o acciones e incrementa o decrementa la variable de control, sino la cumple la condición, se sale del ciclo.
Incremento; que puede ser positivo o negativo (decremento).
Veamos un ejemplo sencillo:
Ejemplo 4.4:
Diseñe un programa que imprima los primeros 10 números:
#include <stdio.h>
#include <conio.h>
main()
{
int i;
for(i=1; i<=10; i++)
printf("%dt", i);
getch();
return 0;
}
ejemplo4.5
Diseñe un programa en C, que calcule las compras totales, realizadas por un grupo de 20 amas de casa. Luego con esa información obtenga la media.
#include <stdio.h>
#include <conio.h>
main()
{
int i;
float compra, desvia, prom, varinza, sum=0;
for(i=1; i<=10; i++)
{
printf("Ingrese la cantidad que gast¢ la ama de casa %d:n", i);
scanf("%f", &compra);
while(compra<0)
{
printf("ERROR, la compra debe ser mayor que cero, vuelva a intentarlo:n";
scanf("%f", &compra);
}
sum=sum+compra;
}
prom=sum/12;
printf("El promedio de las compras es %.2fnna", prom);
getch();
return 0;
}

Cabe, mencionar que, en el ciclo for, podemos hacer cuentas decrecientes, es decir asignarle un valor grande a nuestra variable de control y luego irla disminuyendo hasta un valor determinado.
Ejemplo 4.6
En un cine, se tienen 3 diferentes clases de boletos. Se pide que diseñe un programa en el cual:
a. se lea el precio de las 3 clase de boletos
b. Se lea el numero de boletos vendidos de cada tipo
c. Calcular cual boleto es el que se vendió menos
d. El total recaudado en taquilla
Además se sabe que durante el día se realizaron un total de n ventas.
#include <stdio.h>
#include <conio.h>
main()
{
float preciob1, preciob2, preciob3, sum=0, sum1=0, sum2=0, sum3=0;
int n, i, boletos1, boletos2, boletos3, boleto;
clrscr();
printf("ttBIENVENIDO(A)nnn";
printf("Ingrese el precio de los boletos 1:n";
scanf("%f", &preciob1);
while(preciob1<0)
{
printf("ERRORn";
scanf("%f", &preciob1);
}
printf("Ingrese el precio de los boletos 2:n";
scanf("%f",&preciob2);
while(preciob2<0)
{
printf("ERRORn";
scanf("%f", &preciob2);
}
printf("Ingrese el precio de los boletos 3:n";
scanf("%f",&preciob3);
while(preciob3<0)
{
printf("ERRORn";
scanf("%f", &preciob3);
}
printf("¨Cu ntas ventas se realizaron este d¡a?:n";
scanf("%d", &n);
while(n<0)
{
printf("ERRORn";
scanf("%d", &n);
}
for(i=1; i<=n; i++)
{
printf("Ingrese el Boleto:n";
scanf("%d", &boleto);
switch(boleto)
{
case 1: printf("Ingrese la cantidad de boletos vendidos:n";
scanf("%d", &boletos1);
sum1+=boletos1;
sum=sum+(boletos1*preciob1);
break;
case 2: printf("Ingrese la cantidad de boletos vendidos:n";
scanf("%d", &boletos2);
sum2+=boletos2;
sum=sum+(boletos2*preciob2);
break;
case 3: printf("Ingrese la cantidad de boletos vendidos:n";
scanf("%d", &boletos3);
sum3+=boletos3;
sum=sum+(boletos3*preciob3);
break;
default: printf("ERROR, Vuelva a intentarlonn";
break;
}
}
clrscr();
if(sum3<sum2 && sum3<sum1)
printf("Los Boletos que se vendieron menos fueron los boletos numero UNOnn";
if(sum2<sum3 && sum2<sum1)
printf("Los Boletos que se vendieron menos fueron los boletos numero DOSnn";
if(sum1<sum2 && sum1<sum3)
printf("Los Boletos que se vendieron menos fueron los boletos numero TRESnn";
printf("El total recaudado en taquilla, durante este dia fue: %.2fnn", sum);
getch();
return 0;
}
Ciclo Do... while
Es te ciclo funciona de la siguiente manera, realiza la acción o conjunto de acciones, luego evalúa una condición de resultar cierta vuelve a realizar la/s accion/es. Cuando sea falsa, se sale del ciclo. Esta estructura, no está lógicamente, estructurada, por ello, no hablaremos mucho, sin embargo realizaremos un par de ejemplos, de este ciclo.
Formato :
do {
sentencia;
.
.
} while(<expL>;
La diferencia fundamental, entre el ciclo while y do...while, es que en este ultimo, las sentencias se realizarán por lo menos una vez, en cambio, con while, solo se cumplirán mientras se cumpla la condición, lo cual puede ser nunca.
Ejemplo 4.7
Programa que determina si un año es bisiesto o no. Y un año es bisiesto si es múltiplo de cuatro, pero excluyendo aquellos que son múltiplos de 100 pero no de 400
#include <stdio.h>
#include <conio.h>
void main()
{
int anio;
char respuesta;
printf("nnnINICIO DEL PROGRAMAnnn";
printf("nnEl programa te pide un anio y te dice exactamente si es bisiesto o no";
do
{
/*ENTRADA DE DATOS*/
printf("nnIntroduzca un anio determinado ";
scanf("%d",&anio);
/*PROCESO Y SALIDA DE DATOS*/
if ((anio%4==0 && anio%100!=0)||(anio%400==0)) printf("nnEl anio es bisiesto";
else printf("nnEl anio no es bisiesto";
printf("nnDesea introducir mas datosnn";
respuesta=getch();
} while(respuesta=='S' || respuesta=='s');
printf("nnnFIN DEL PROGRAMAnnn";
}
NOTA: este código ha sido tomado de "Practicas de Programación en C", de Fernando Muñoz Ledesma. Practica 3, ejercicio 5.
Cuestionario
1. ¿qué es y cómo funciona un ciclo?____________________________________________________________________________________________________________________
2. Cuál es la diferencia entre un contador y un acumulador:_____________________________________________________________________________________________________________
3. ¿cuál es la mejor manera de validar datos?:_________________________________________________________________________________________________________________
4. ¿cómo se evita un ciclo infinito?:__________________________________________________________________________________________________________________
5. ¿Qué diferencia existe entre un ciclo de entrada asegurada y el do... while?:______________________________________________________
Descubre donde está el error.
El siguiente código muestra la serie:
1^2+2^2+3^2....n^2
en el cual hay errores de lógica, de sintaxis o hasta de ejecución, puedes descubrirlos y corregirlos?
#include <stdio.h>
#include <conio.h>
main()
{
int n i, x, sum=0;
printf("Inrtroduzca el valor de n:n";
scanf("%d", &n);
while(n<0)
{
printf("Error, vuelva a digitar el valor de n:n";
scanf("%d", n);
}
for(i=1; i<=n, i++)
x=i*i;
sum+=n;
printf("El valor de la suma es:%dnn", sum)
getch();
return 0;
}
Ejercicios
1. Se desea conocer la suma de los números enteros, positivos menores que n, el cual es un dato dado por el usuario.
2. Muestre un programa en c, que imprima en pantalla los números desde un valor inicial, hasta un valor final, ingresados por el usuario, tanto en forma descendente como ascendente.
3. Diseñe un programa que imprima la serie de Fugonacci, así: 0 1 1 2 3 5 8 13.... hasta un número n dado por el usuario.
4. Calcule el promedio de edades de un grupo de estudiantes, de los cuales no se conoce la cantidad.
5. Diseñe un programa que obtenga, la calificación mayor y la calificación menor, de un grupo de 40 estudiantes, además de los nombres de dichos alumnos.
6. En un país hubieron elecciones para elegir al presidente. El país consta de 7 provincias o regiones, de las cuales se han levantado actas que contiene el total de votos obtenidos por los 4 partidos políticos en dicha región. Diseñe un programa en c, que lea las actas de las 7 provincias, muestre que partido ganó las elecciones y en caso de empate, lo especifique con un mensaje.
7. en un supermercado, hay 3 departamentos (de ropa, comestibles y perfumería), en lo cuales se realizan un descuento de 5%, 3.5% y 8% respectivamente, por las compras totales mayores de $100.00. diseñe un programa que dado el monto de la compra, realice los descuentos pertinentes por departamento, le indique al usuario a cuanto asciende su nuevo monto e indique, cuanto fue lo recaudado al final del día.
8. La Empresa, el porvenir s.a de c.v desea conocer lo que debe pagar en concepto de horas extras aun grupo de n empleados. Se sabe que una hora extra diurna, se paga el doble que una hora normal. Y una hora extra nocturna se paga el doble de una hora normal más el 25%. Además que todos los empleados tiene sueldos diferentes, muestre el nuevo sueldo de cada uno de ellos y lo que tendrá que pagar la empresa en concepto de horas extra.
9. Una compañía de teléfonos, cobra $0.03 por minuto la llamada nacional local, $0.06 por la llamada de larga distancia nacional y $0.10 la llamada de larga distancia internacional. Diseñe un programa que calcule las facturas mensuales de los clientes, sabiendo que, si las llamadas fueron realizadas por la mañana tienen un doble valor, y si los 10 primeros minutos de llamadas locales son gratis, en cualquier horario.
Capítulo V: Funciones en C
La modularización, es una técnica usada por los programadores para hacer sus códigos más cortos, ya que consiste en reducir un gran problema complejo, en pequeños problemitas más sencillos, concentrándose en la solución por separado, de cada uno de ellos.
En C, se conocen como funciones aquellos trozos de códigos utilizados para dividir un programa con el objetivo que, cada bloque realice una tarea determinada.
En las funciones juegan un papel muy importe las variables, ya que como se ha dicho estas pueden ser locales o globales.
Variables Globales: Estas se crean durante toda la ejecución del programa, y son globales, ya que pueden ser llamadas, leídas, modificadas, etc; desde cualquier función. Se definen antes del main().
Variables Locales: Estas, pueden ser utilizadas únicamente en la función que hayan sido declaradas.
La sintaxis de una función es la siguiente:
Tipo_de_datos nombre_de_la_funcion(tipo y nombre de argumentos)
{
acciones
}
donde:
• Tipo_de_datos: Es el tipo de dato que devolverá esa función, que puede ser real, entera, o tipo void(es decir que no devolverá ningún valor).
• Nombre_de_la_funcion: Es el identificador que le damos a nuestra función, la cual debe cumplir las reglas que definimos en un principio para los identificadores.
• Tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos de una función no son más que variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir funciones que no reciban argumentos.
• Acciones: Constituye el conjunto de acciones, de sentencias que cumplirá la función, cuando sea ejecutada. Entre ellas están:
1. Asignaciones
2. Lecturas
3. Impresiones
4. Cálculos, etc
Una función, termina con la llave de cerrar, pero antes de esta llave, debemos colocarle la instrucción return, con la cual devolverá un valor específico. Es necesario recalcar que si la función no devuelve ningún valor, es decir, es tipo void, no tiene que ir la sentencia return, ya que de lo contrario, nos dará un error.
Pero, es válido que nos hagamos la siguiente pregunta:
¿Cómo es que funcionan los Subprogramas?
A menudo, utilizamos el adjetivo de "Subprogramas", para referirnos a las funciones, así que, el lector debe familiarizarse también con este término.
Los subprogramas se comunican con el programa principal, que es el que contiene a las funciones, mediante parámetros, que estos pueden ser: Parámetros Formales y Parámetros Actuales.
Cuando se da la comunicación los parámetros actuales son utilizados en lugar de los parámetros formales.
Paso de Parámetros
Existen dos formas de pasar parámetros, las cuales son:
A. Paso por Valor
También conocido como parámetros valor. Los valores se proporcionan en el orden de cálculos de entrada.
Los parámetros se tratan como variables locales y los valores iniciales se proporcionan copiando los valores de correspondientes argumentos.
Los parámetros formales-Locales de una función reciben como inicilaes los valores de los parámetros actuales y con ellos se ejecutan las acciones descritas en el subprograma.
Ejemplo:
A=5;
B=7;
C=proc1(A, 18, B*3+4);
Proc1(X, Y, Z)
Explicación:
Donde, se encuentra c, se está llamando la función, denominada proc1, en la cual se están enviando como parámetros el valor de A, que es cinco; el cual es recibido por la variable X, en la definición de la función proc1; en la misma función, Y tendrá el valor de 18; por que ese es el valor del parámetro formal, mientras que Z, tendrá un valor inicial de 25, ya que ese es el resultado del tercer parámetro que resulta ser una expresión aritmética.
Funciones Definidas Por El Usuario en C
Una función, como ya se ha dicho, es un bloque de código dentro del programa que se encarga de realizar una tarea determinada. Por lo tanto un programa en c debe constar de una o más funciones, y por su puesto no puede faltar la función principal main().
Un viejo adagio dice: Separa y vencerás, lo cual se acopla perfectamente cuando tenemos un programa que es bastante grande; podemos separarlos en pequeños subprogramas (funciones), y concentrarnos en la solución por separados de cada uno de ellos y así resolver un gran problemas, en unos cuantos problemitas más pequeños.

Si un programa, está constituido por más de una función, las llamadas a la misma, pueden realizarse desde cualquier parte del programa, y la definición de ellas debe ser independiente unas de otras.
Por lo tanto sería un grave error el tratar de definir una función dentro de otra.
Una función puede ser llamada desde cualquier parte del programa no sólo una vez, y cuando es llamada, empieza a ejecutar las acciones que están escritas en código.
Para mayor comodidad del lector vamos a ver varios ejemplos, del uso de funciones y a medida que vayamos avanzando se volverán más complejos.
El orden será el siguiente:
5. Funciones que no devuelven ningún valor
6. Funciones que devuelven un valor entero
7. Funciones que devuelven un valor Real
8. Funciones combinadas
9. Funciones en las que usamos Menú.
10. Funciones que no devuelven ningún valor.
Cómo se ha dicho las funciones pueden o no devolver algún valor, para mi parecer, este tipo de funciones son las más sencillas, ya que cuando se llama la función, esta realiza lecturas, asignaciones, cálculos o impresiones, finaliza la ejecución de la función y el programa continúa normalmente.
Ejemplo 5.1
Diseñe un programa que dados dos números enteros determine la suma y cual de ellos es mayor, usando dos funciones diferentes.
#include <stdio.h>
#include <conio.h>
void suma (int a, int b); /*Declaraci¢n de la funci¢n*/
void mayor (int a, int b); /*Tipo de dato, nombre de la funci¢n y el tipo y nombre de los argumentos*/
main()
{
int a, b;
printf("Ingrese el valor de a:n";
scanf("%d", &a);
printf("Ingrese el valor de b:n";
scanf("%d", &b);
suma(a,b); /*Llamado de la funci¢n*/
mayor(a,b); /*Unicamente el nombre de la funci¢n y de los par metros*/
getch();
return 0;
}
void suma(int a, int b) /*Definici¢n de la funci¢n*/
{ /*Abrimos llaves al inicio de la definici¢n*/
int sum; /*Declaraci¢n de las variables locales*/
sum=a+b;
printf("El valor de la suma es %d:nn", sum);
} /*Fin de la funci¢n suma*/
void mayor(int a, int b)
{
if(a==b)
printf("Son igualesnn";
else
{
if(a>b)
printf("El valor de a es mayor que el de bnn";
else
printf("El valor de b es mayor que el de ann";
}
}
Definición de la Función
La función ha sido declarada, ha sido llamada y por lo tanto deber haber sido definida. Lo cual consta de dos partes, las cuales son:
11. La Primera Línea
Que como su nombre lo indica, es la primera línea de la definición de la función y con ella le indicamos al compilador que está en presencia de una función. Su formato es el siguiente:
Tipo_de_dato nombre_de_la_función (tipo y nombre de los argumentos)
12. Cuerpo de la función
Se inicia con una llave "{", y en ella, se pueden realizar asignaciones, cálculos, impresiones, así como la declaración de las variables locales. Puede estar constituidas por estructuras secuenciales, selectivas, iterativas, anidamientos, se pueden llamar otras funciones, etc; finaliza con "}". Puede devolver uno o ningún valor.
Ejemplo 5.2
Diseñe un Programa en C, que Dado un número entero y mayor que cero, Determine si es o no un número Primo. Ojo, los números primos sólo son divisibles por el mismo y por la unidad (1).
#include <stdio.h>
#include <conio.h>
void primo (int numero);
main()
{
int numero, ban=1;
clrscr();
while(ban==1)
{
printf("Introduzca el n£mero por favor:n";
scanf("%d", &numero);
while(numero<0)
{
printf("ERROR, el valor del n£mero debe ser mayor que ceron";
scanf("%d", &numero);
}
primo(numero);
printf("¨Otro n£mero (si=1 y No=0)?n";
scanf("%d", &ban);
}
getch();
return 0;
}
void primo (int numero)
{
int div, primo=1;
for(div=2; div<numero; div++)
{
if(numero%div==0)
{
primo=0;
printf("%d NO es primonnn", numero);
return 0;
}
else
primo=1;
}
if(primo!=0)
printf("%d es primonnn", numero);
}
13. Funciones que devuelven un valor entero
Las funciones que devuelven algún valor, se les llama PROTOTIPOS DE FUNCIONES:
Antes de usar una función C debe tener conocimiento acerca del tipo de dato que regresara y el tipo de los
parámetros que la función espera.
El estándar ANSI de C introdujo una nueva (mejor) forma de hacer lo anterior respecto a las versiones previas
de C.
La importancia de usar prototipos de funciones es la siguiente:
Se hace el código mas estructurado y por lo tanto, más fácil de leer.
Se permite al compilador de C revisar la sintaxis de las funciones llamadas.
Lo anterior es hecho, dependiendo del alcance de la función. Básicamente si una función ha sido definida antes
de que sea usada (o llamada), entonces se puede usar la función sin problemas.
Si no es así, entonces la función se debe declarar. La declaración simplemente maneja el tipo de dato que la
función regresa y el tipo de parámetros usados por la función.
Es una práctica usual y conveniente escribir el prototipo de todas las funciones al principio del programa, sin
embargo esto no es estrictamente necesario.
Para declarar un prototipo de una función se indicara el tipo de dato que regresará la función, el nombre de la
función y entre paréntesis la lista del tipo de los parámetros de acuerdo al orden que aparecen en la definición de la
función. Por ejemplo:
int longcad(int n); Lo anterior declara una función llamada longcad que regresa un valor entero y acepta otro valor entero como parámetro.
(Tomado de "Manual de C" de Héctor Tejada Villela)
Ejemplo 5.3
Diseñe un programa, que dado un número entero y mayor que cero, muestre su factorial. (El factorial de 5 es 120; 5x4x3x2x1=120)
#include <stdio.h>
#include <conio.h>
int factorial (int num);
main()
{
int num, ban=1;
clrscr();
while(ban==1)
{
printf("Ingrese el valor del n£mero por favor:n";
scanf("%d", &num);
while(num<0)
{
printf("ERROR, el valor del n£mero debe ser mayor que cero:n";
scanf("%d", &num);
}
printf("El valor del factorial es %dnn", factorial (num));
printf("¨Desea Realizar otro calculo?Si=1 y No=0n";
scanf("%d", &ban);
}
getch();
return 0;
}
int factorial (int num)
{
int sum=1, i;
for(i=2; i<=num; i++)
{
sum=sum*i;
}
return (sum);
}
Explicación:
Quizá, lo único nuevo, e importante de explicar, radica en la llamada y la definición de la función. Cuando una función nos devolverá un valor entero, al identificador de dicha función debe precederle el tipo de dato. En el lugar, donde llamamos la función, es que aparecerá el valor que nos devuelva, como valor de retorno. En nuestro ejemplo, en una impresión. Y al momento de definirla, no se nos debe olvidar, colocarle la sentencia return(); ya que, mediante esta declaratoria, está retornando el valor calculado.
Pero, que sucede cuando se está trabajando, con valores bastante grandes, al utilizar solamente el int, se producirá un error lógico; ya que como valor de retorno podría ser un cero o una cifra negativa. Por tanto debemos usar el tipo de dato "long int".
Ejemplo 5.4
Diseñe un programa, que dada una cifra entera y mayor que cero, sea elevada a una potencia introducida por el usuario, la cual. (Ejemplo: 5^2=25).
#include <stdio.h>
#include <conio.h>
long int potencia (int base, int exponente);
main()
{
int base, exponente;
clrscr();
printf("La Base es:n";
scanf("%d", &base);
while (base<0)
{
printf("ERROR, el dato debe ser mayor que cero:n";
scanf("%d", &base);
}
printf("El Exponente es:n";
scanf("%d", &exponente);
printf("%d ^ %d es %ldnn", base, exponente, potencia(base,exponente));
getch();
return 0;
}
long int potencia (int base, int exponente)
{
long int sum=0, i,x;
for(i=1; i<exponente; i++)
{
x=base*base;
sum=sum+x;
}
return (sum);
}