Los tipos de funciones en c++ son 4, aunque en realidad son las combinaciones de las 2 cosas

que una funcin puede hacer. Si andan perdidos en cuanto a funciones les recomiendo leer mi
post anterior:Funciones en C++.
Una funcin, como les deca, puede hacer (o no) dos cosas: 1 Recibir datos y 2 Retornar
datos. De esto surgen los cuatro tipos de funciones:
1. No reciben ni retornan
2. Reciben y no retornan
3. No reciben y retornan
4. Reciben y retornan
Vamos a hacer un programa que sume dos nmeros, usando los cuatro tipos de funciones:

No reciben ni retornan
Las ms sencillas. Para usarlas slo tenemos que saber cmo crearlas y cmo llamarlas. Una
funcin se crea de esta forma general:
tipo nombre(){}
El tipo se refiere al tipo de dato (int, float, void, char) y en las funciones que no retornan
siempre es void.
El nombre es el nombre de la funcin: cualquiera que empiece con una letra, que sea
significativo y que no sea una palabra reservada.
Para llamarlas slo hay que escribir el nombre de la funcin seguido de sus parntesis y un
punto y coma (;).
nombre();

As nuestro programa sera:

#include<iostream>
using namespace std;

void sumar()
{
int num1, num2, r;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
r = num1 + num2;
cout << "La suma es " << r;
}

int main()
{
sumar();
}

Como ven, todo lo que habramos puesto en nuestro main mejor los pusimos en una funcin y
desde el main la llamamos. Una funcin siempre, siempre, siempre tiene que ir antes del main.
Una funcin de este tipo que hemos usado muchas veces es getch();

Reciben y No Retornan
Cmo haramos para pedir los dos nmeros en el main y que la funcin haga la suma? Para eso
tenemos que hacer una funcin capaz de recibir datos, entonces la sintaxis cambia un poco:
tipo nombre(tipo_var1 nombre_var1, tipo_var2 nombre_var2){}
tipo y nombre se refieren a lo mismo y como no retorna el tipo siempre es void.
Dentro del parntesis tenemos otros aspectos:

tipo_var1 se refiere al tipo de la variable que nuestra funcin va a recibir.

nombre_var1 se refiere al nombre de esa variable.
Si queremos recibir una variable hasta ah es suficiente, si queremos otra variable ponemos
una coma (,) y declaramos la siguiente variable.
Para llamar la funcin hay que poner la variables que vamos a enviar dentro del parntesis en
el mismo orden en que las declaramos en la funcin:
nombre(var1, var2);

Nuestro programa quedara as:

#include<iostream>
using namespace std;

void sumar(int num1, int num2)

{
int r;
r = num1 + num2;
cout << "La suma es " << r;
}

int main()
{
int num1, num2;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
sumar(num1, num2);
}

Pedimos los dos nmeros en el main, los enviamos a la funcin, sta los suma y los muestra.

Una funcin de este tipo que hemos usado muchas veces es el odiado por muchos, amados por
otros,gotoxy(x,y);

Retornan y No Reciben
Y si ahora queremos lo contrario? Pedir los nmeros en la funcin, pero mostrar el resultado
en el main. Para eso necesitamos una funcin que retorne.
Recibir es enviar datos del main a la funcin. Retornar es enviar datos de la funcin al main.
Para retornar datos hay que hacer dos cosas: no usar void como tipo y usar return.
De forma general:
tipo nombre() { return var; }
El tipo tiene que ser del tipo de variable que queremos retornar, si nuestra variable retorna
una variable int, pues el tipo de la funcin es int.
Para indicar qu variable estamos retornando usaremos la palabra return seguido de la
variable. Usualmente esto va al final de la funcin.
Para llamar a la funcin hay que preparar un colchn en donde caiga la variable que est
retornando.
var = nombre();
La variable que est retornando nuestra funcin se va a almacenar en la variable var. Este
es un buen momento para recordarles que las variables declaradas entre dos llaves {}
nicamente existen entre esas dos llaves. O sea que la variable var de la funcin no es la
misma que la variable var de la funcin; sin embargo la var del main est adquiriendo el
valor de la var del main. Un poco confuso lo se, no se preocupen.
Nuestro programa quedara as:
#include<iostream>
using namespace std;

int sumar()
{
int num1, num2, r;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
r = num1 + num2;
return r;
}

int main()
{
int r;
r = sumar();
cout << "La suma es " << r;
}

A alguien se le ocurre una funcin conocida de este tipo?

Reciben y Retornan
Ahora queremos que nuestra funcin nicamente sume, el main se va a encargar de pedir los
nmeros y sumar los resultados. Para eso necesitamos que nuestra funcin reciba las variables
y adems retorne el resultado. Wow! Es acaso eso posible? Claro que s.
Es slo cuestin de combinar las funciones que reciben y no retornan con las que retornan y
no reciben.
Nuestro programa quedara as:
#include<iostream>
using namespace std;

int sumar(int num1, int num2)

{
int r;
r = num1 + num2;
return r;
}
int main()
{
int num1, num2, r;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
r = sumar(num1, num2);
cout << "La suma es " << r;
}

Las funciones de la librera math.h son en su mayora de este tipo. sqrt(); pow(); sin();

En principio puede parecer que las funciones sirven nicamente para organizar el cdigo, lo
cual es cierto, pero no slo eso. Se imaginan si tuviramos que escribir todo el cdigo detrs
de un simplegotoxy();? Ah verdad
Bueno, no me iba a quedar tranquilo si no les mostraba la versin optimizada de la ltima
funcin:
#include<iostream>
using namespace std;

int sumar(int num1, int num2)

{
return num1 + num2;
}

int main()
{
int num1, num2;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
cout << "La suma es " << sumar(num1, num2);
}

:D

Supongo que ya es hora de retomar el blog y ponerme a hablar de funciones en c++. Una
funcin es un pedazo de cdigo fuera del main, con un nombre y que puede ser llamado
desde otra parte de nuestro programa.
Imagnense que estn entrenando a su perro a hacerse el muertito. Cada vez que ustedes dicen
muertito, el perro se tira de espaldas en el suelo, cierra los ojos y saca la lengua. En
programacin, elcontenido de la funcin sera tirarse de espaldas, cerrar los ojos y sacar la
lengua; el nombre de la funcin sera muertito; y cada vez que nosotros
decimos muertito estamos llamando a la funcin.
Nuestra funcin sera algo as:
void muertito()
{
Perro.Tirarse(posicion='espalda');
Perro[OjoDer].Cerrar();
Perro[OjoIzq].Cerrar();
Perro[Lengua].Sacar();
}
Jajaja, bueno, bueno. Ya en serio vamos a hacer un clsico Hola Mundo pero usando una
funcin:
#include<iostream>
using namespace std;
void hola()
{
cout << "Hola Mundo!";
}
int main()
{
hola();
}

Como ven, esta funcin es muy estpida. No nos beneficia en nada y nos hace escribir ms
cdigo del necesario, pero nos sirve para ver cmo acta una funcin: al momento de llamar
a la funcin, el compilador se brinca a la funcin, la ejecuta y cuando termina, vuelve al punto
desde donde brinc.
Si pudieran leerle la mente a un compilador, este dira:
Linea 1. Incluir la librera iostream. OK
Linea 2. Usar el namespace estndar. OK
Linea 3. Oh! una funcin llamada hola, la recordar.
Linea 4. Llave. Parte de la funcin. Ignorar
Linea 5. Imprimir Hola Mundo!. Parte de la funcin. Ignorar
Linea 6. Llave. Parte de la funcin. Ignorar
Linea 7. Por fin el main!
Linea 8. Llave. Entrar
Linea 9. Esta funcin se me hace conocida oh s ya recuerdo. Ejecutar lineas 4, 5 y 6
Linea 10. Llave. Salir
Ahora veamos una funcin que s nos es til:
#include<iostream>
using namespace std;

void hola(char nombre[50])

{
cout << "Hola " << nombre << "!";
}

int main()
{
char nombre[50];
cout << "Cual es tu nombre?: "; cin.getline(nombre, 50, '\n');
hola(nombre);
}

Primero pedimos un nombre, lo guardamos en una variable y se le mandamos a la funcin para

que lo muestre.
No se preocupen, si nunca haban visto una funcin tal vez no entiendan la sintaxis, pero el
objetivo de este post es que sepan qu es una funcin y para qu se puede usar. En el siguiente
post voy a explicar la sintaxis de los cuatro tipos de funciones en c++.
Bueno, casi creo que nunca he hablado de matrices, parmetros o funciones en este blog,
pero este post es una peticin de Rodrigo que me dijo por email que tena problemas con su
tarea porque no sabecmo pasar una matriz como parmetro a una funcin en c++. Es
algo sencillo, pero difcil de deducir. Veamos.
Si tu arreglo es de una dimensin
int matriz[4];
la forma de declarar la funcin es la siguiente:
void fx(int m[4]) { ...cdigo... }
Y la forma de llamar la funcin sera:
fx(matriz);
Si el arreglo es de dos dimensiones
int matriz[4][3];
pues es lo mismo:
void fx(int m[4][3]) { ...cdigo... }
Y la forma de llamar la funcin sera:
fx(matriz);
Si la funcin retorna una matriz
int matriz[4];
se declara normal:
void fx(int m[4]) { return matriz[4]; }
Y la forma de llamar la funcin sera:
matriz[4] = fx(matriz);

Este programa pide tres nmeros, los almacena en una matriz, le suma 1 a cada elemento y
los muestra, usando para cada accin una funcin. As que tenemos funciones que reciben
matrices y que retornan matrices. Chquenlo.
#include<iostream>
using namespace std;

void pedir(int matriz[3], int len)

{
for(int i=0; i<=len; i++)
{
cout << "Numero " << i+1 << ":? ";
cin >> matriz[i];
}
}

int sumar(int matriz[3], int len)

{
for(int i=0; i<=len; i++)
matriz[i]++;
return matriz[3];
}

void mostrar(int matriz[3], int len)

{
for(int i=0; i<=len; i++)
cout << matriz[i] << " ";
}
 int main()
{
int matriz[3]={0}, len = sizeof(matriz)/sizeof(int);
pedir(matriz, len-1);
matriz[3] = sumar(matriz, len-1);
mostrar(matriz, len-1);
return 0;
}

Funcin delay() en C++

Una funcin a veces til a veces no mucho es el delay(), sirve para hacer una pausa de n
segundos. En algunos compiladores Borland esta funcin se incluye en la librera conio.h
pero como aqu estamos del lado del software libre vamos a hacer nosotros mismos esta
funcin. Primero veamos cmo se usa:
delay(variable_tipo_int);
es decir:
int secs=10;
delay(secs);
o
delay(numero_entero);
es decir:
delay(12);
Y claro, la funcin es esta:
void delay(int secs) {
for(int i = (time(NULL) + secs); time(NULL) != i; time(NULL));
}
1. La funcin time(NULL) nos devuelve el segundo exacto en que estamos.
2. Si le sumamos cierta cantidad de segundos obtenemos una fecha en el futuro.
3. En cada vuelta del ciclo se checa si esa fecha en el futuro es diferente a la fecha actual.
4. En cuanto las dos fechas son iguales el ciclo acaba y el programa contina.
Veamos como se usa en un programa en c++:
#include<time.h>
#include<iostream>
using namespace std;

void delay(int secs) {

for(int i = (time(NULL) + secs); time(NULL) != i; time(NULL));
}

int main()
{
int sec;
cout << "Segundos a pausar?: "; cin >> sec;
delay(sec);
}
Para poder usar la funcin delay de esta forma es necesario ponerla en todos los programas
en donde necesitemos usarla (ahora me doy cuenta que no he escrito mucho sobre funciones)
e incluir siempre la librera #include<time.h> o #include<ctime>.
15 Comentarios
Ordenar arreglo de manera ascendente o
descendente (burbuja)
Programa que lee un arreglo de 10 nmeros y los ordena con el mtodo de la burbuja de
maneraascendente o descendente segn se elija. Para esto utiliza una funcin que recibe el
arreglo y la varible ord (1=asc, 2=desc), luego utiliza otra funcin para imprimirlo.
#include<iostream>
using namespace std;

int ordenar(int[],int);
int imprimir(int[]);

int main()
{
int c,lista[9],ord;
for(c=0;c<=9;c++)
{
cout<<"Numero "<<c+1<<": "; cin>>lista[c];
}
cout<<"\nAscendente 1\nDescendente 2\n--> Opcin: "; cin>>ord;
if(ord==1 || ord==2)
{
ordenar(lista,ord);
imprimir(lista);
}
}

int ordenar(int lista[],int ord)

{
int c1,c2,aux;
for(c1=0;c1<=9;c1++)
{
for(c2=0;c2<9;c2++)
{
if(ord==1)
{
if(lista[c2]>lista[c2+1])
{
aux=lista[c2];
lista[c2]=lista[c2+1];
lista[c2+1]=aux;
}
}
else
{
if(lista[c2]<lista[c2+1])
{
aux=lista[c2];
lista[c2]=lista[c2+1];
lista[c2+1]=aux;
}
}
}
}
 return 0;
}

int imprimir(int lista[])

{
int c;
for(c=0;c<=9;c++)
cout<<lista[c]<<" ";
cin.get();cin.get();
}

#!)

#'!'

- !
)
Z

1.- Realizar una funcin llamada par, que

toma un nmero entero como parmetro, y

devuelve 1 si es par o devuelve 0 si es

impar. NOTA: Para saber si un nmero entero

es par, al dividirlo entre 2 su resto debe

ser 0.

/* mpar.c: Permite probar la funcin par. */

#include<stdio.h>

int par(int); // o int par(int numero);

int main()

int numero, resultado;

printf(Introduzca un nmero:\n);

scanf(%i,&numero);
resultado=par(numero);

if (resultado==1)

printf(Es par.\n);

else

printf(Es impar.\n);

return(0);

/* Funcin par: Devuelve un valor indicando si un

nmero entero es par o no. */

int par(int numero)

if((numero%2)==0)

return(1);

else

return(0);

- Si la funcin se llama par, tendr el prototipo con la siguiente estructura:

<tipo> par(<parmetros>);

- Si nos dicen que toma un parmetro que es un nmero entero, quiere decir que es de tipo int el

nico parmetro que tiene, adems deberemos inventarnos un nombre para esa variable que va
entre

parntesis, por ejemplo numero, as tendr el prototipo:

<tipo> par(int numero);

- Si nos dicen que devuelve 1 o 0, en funcin de si es par o no, quiere decir que el tipo del dato
que devuelve es el tipo del 1 o el 0, es decir devuelve un nmero entero, por tanto de tipo int,

quedando finalmente as el prototipo de la funcin:

int par(int numero);

- Si nos dicen que la funcin devuelve algo, quiere decir que en algn momento debe devolver con

una funcin return un valor, por tanto, si debe devolver 0 o 1, en algn sitio debe haber un

return(0); o un return(1);

- Si nos dicen que la funcin devuelve algo, ese algo que devolver deber recogerse desde la

funcin main en una variable del mismo tipo que el valor devuelto. En nuestro caso, como par

devuelve un nmero entero (0 o 1) deberemos declarar en la funcin main una variable entera en
la

que luego se almacenar el valor devuelto por par.

int main()

int resultado;

resultado=par(numero);

NOTA: Lo lgico si se programa una funcin que detecta si un nmero es par, es que devuelva un
S

si es par o un NO si no es par, el problema es que el lenguaje C no tiene este tipo de valores; as

que se suelen devolver un 1 como S y un 0 como NO, en cualquier funcin que tenga que
responder S

o NO a algo (por ejemplo, una funcin que diga si un nmero es negativo, devolver 1 si s lo es y

un 0 si no lo es).

6. Funciones
 Una funcin es un conjunto de declaraciones, definiciones,
expresiones y sentencias que realizan una tarea especfica.

El formato general de una funcin en C es

especificador_de_tipo nombre_de_funcin( lista_de_parmetros )

{
variables locales
cdigo de la funcin
}

El especificador_de_tipo indica el tipo del valor que la funcin

devolver mediante el uso de return. El valor puede ser de cualquier
tipo vlido. Si no se especfica un valor, entonces la computadora
asume por defecto que la funcin devolver un resultado entero. No
se tienen siempre que incluir parmetros en una funcin. la lista de
parmetros puede estar vaca.

Las funciones terminan y regresan automticamente al

procedimiento que las llam cuando se encuentra la ltima llave }, o
bien, se puede forzar el regreso antes usando la sentencia return.
Ademas del uso sealado la funcin return se usa para devolver un
valor.

Se examina a continuacin un ejemplo que encuentra el promedio

de dos enteros:
float encontprom(int num1, int num2)
{
float promedio;

promedio = (num1 + num2) / 2.0;

return(promedio);
}

main()
{
int a=7, b=10;
float resultado;

resultado = encontprom(a, b);

printf("Promedio=%f\n",resultado);
}

6.1 Funciones void

Las funciones void dan una forma de emular, lo que en otros
lenguajes se conocen como procedimientos (por ejemplo, en
PASCAL). Se usan cuando no requiere regresar un valor. Se
muestra un ejemplo que imprime los cuadrados de ciertos nmeros.
void cuadrados()
{
int contador;

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

printf("%d\n",contador*contador);
}

main()
{
cuadrados();
}

En la funcin cuadrados no esta definido ningn parmetro, y por

otra parte tampoco se emplea la sentencia return para regresar de
la funcin.

6.2 Funciones y arreglos

Cuando se usan un arreglo como un argumento a la funcin, se pasa
slo la direccin del arreglo y no la copia del arreglo entero. Para
fines prcticos podemos considerar el nombre del arreglo sin ningn
ndice como la direccin del arreglo.

Considerar el siguiente ejemplo en donde se pasa un arreglo a la

funcin imp_rev, observar que no es necesario especificar la
dimensin del arreglo cuando es un parmetro de la funcin.
void imp_rev(char s[])
{
int t;

for( t=strlen(s)-1; t>=0; t--)

printf("%c",s[t]);
}

main()
{
char nombre[]="Facultad";

imp_rev(nombre);
}
Observar que en la funcin imp_rev se usa la funcin strlen para
calcular la longitud de la cadena sin incluir el terminador nulo. Por
otra parte, la funcin imp_rev no usa la sentencia return ni para
terminar de usar la funcin, ni para regresar algn valor.

Se muestra otro ejemplo,

float enconprom(int tam, float lista[])
{
int i;
float suma = 0.0;

for ( i=0; i<tam; i++)

suma += lista[i];
return(suma/tam);
}

main()
{
float numeros[]={2.3, 8.0, 15.0, 20.2, 44.01, -3.0, -
2.9};

printf("El promedio de la lista es %f\n",

enconprom(7,numeros) );
}

Para el caso de que se tenga que pasar un arreglo con ms de una

dimensin, no se indica la primera dimensin pero, el resto de las
dimensiones deben sealarse. Se muestra a continuacin un
ejemplo:
void imprtabla(int tamx,int tamy, float tabla[][5])
{
int x,y;

for ( x=0; x<tamx; x++ )

{
for ( y=0; y<tamy; y++ )
printf("t[%d][%d]=%f",x,y,tabla[x][y]);
printf("\n");
}
}

6.3 Prototipos de funciones

Antes de usar una funcin C debe tener conocimiento acerca del tipo
de dato que regresar y el tipo de los parmetros que la funcin
espera.
 El estndar ANSI de C introduj 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 cdigo ms estructurado y por lo tanto, ms fcil de leer.

Se permite al compilador de C revisar la sintaxis de las funciones
llamadas.

Lo anterior es hecho, dependiendo del alcance de la funcin.

Bsicamente si una funcin ha sido definida antes de que sea usada
(o llamada), entonces se puede usar la funcin sin problemas.

Si no es as, entonces la funcin se debe declarar. La declaracin

simplemente maneja el tipo de dato que la funcin regresa y el tipo
de par^o'ametros usados por la funcin.

Es una prctica 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 funcin se indicar el tipo de dato

que regresar la funcin, el nombre de la funcin y entre parntesis
la lista del tipo de los parmetros de acuerdo al orden que aparecen
en la definicin de la funcin. Por ejemplo:
int longcad(char []);

Lo anterior declara una funcin llamada longcad que regresa un valor

entero y acepta una cadena como parmetro.

6.4 Ejercicios
1. Escribir una funcin ``reemplaza'', la cual toma una cadena como
parmetro, le reemplaza todos los espacios de la cadena por un
guin bajo, y devuelve el nmero de espacios reemplazados. Por
ejemplo:
2. char cadena[] = "El gato negro";
3. n = reemplaza( cadena );

deber devolver:
cadena convertida "El_gato_negro"
 n = 2

4. Escribir un programa que lea una lnea de texto en un buffer (una

cadena de caracteres) usando la funcin gets y calcule la longitud
de la lnea (NO usar la funcin strlen).
5. Modificar el programa anterior para que lea un archivo de texto. El
archivo deber redireccionarse al programa, debiendo mostrar el
contenido del mismo. En caso de que se lea una lnea con longitud
0 deber terminar el programa.

Funciones
Las funciones se declaran y se definen exactamente igual que en C, y, al igual
que en ste, se puede utilizar prototipo (prototype).
Un prototipo es un modelo limitado de una entidad ms completa que aparecer
despus. En el caso de funciones, la funcin es la entidad completa que vendr
despus, y la declaracin de dicha funcin es el prototipo. El prototipo da un
modelo de la interface a la funcin. Veamos un ejemplo:
# include <iostream.h>

void do_stuff (int wings, float feet, char eyes);

main()
{
int arm = 2;
float foot = 1000.0;
char lookers = 2;

do_stuff (3, 12.0, 4);

do_stuff (arm, foot, lookers);
}

void do_stuff (int wings, float feet, char eyes)

{
cout << "There are " << wings << "wings." << '\n';
cout << "There are " << feet << "feet. " << '\n';
cout << "There are " << int(eyes) << "eyes." << '\n';
}

La salida de este programa ser:

There are 3 wings.
There are 12 feet.
There are 4 eyes.
There are 2 wings.
There are 1000 feet.
There are 2 eyes.

Cada llamada a la funcin do_stuff() debe verificar:

El nmero de parmetros debe ser exactamente tres.

Los tipos deben ser compatibles con los de la declaracin (ms adelante
explicaremos qu son tipos compatibles).

Ntese que cuando llamamos a la funcin, la comprobacin de tipo la hace el

compilador basndose en el prototipo (en la declaracin) puesto que la funcin
todava no ha sido definida.
Los nombres de variables que aparecen en el prototipo son opcionales y actan
casi como comentarios al lector del programa, ya que son completamente
ignorados por el compilador.

Tipos compatibles

Son compatibles cualquiera de los tipos simples (definidos en C++) que pueden
ser convertidos de uno a otro de manera significativa. Por ejemplo, si llamamos
con un entero a una funcin que est esperando un nmero real como parmetro,
el sistema lo convertir automticamente, sin mencionarlo al usuario. Esto
tambin es cierto de float a char, o de char a int.
En cambio, si pasamos un puntero a un entero a una funcin que estaba
esperando un entero, no habr conversin de tipo, ya que son dos variables
completamente distintas. De la misma forma, un tipo definido por el usuario
(estructura o clase) no puede ser convertido automticamente a un long float, a
un array o incluso a otra estructura o clase diferente, porque son tipos
incompatibles y no puede realizarse la conversin de manera significativa.
Sin embargo, el tipo devuelto por la funcin, void en el ejemplo anterior, debe
ser compatible con el tipo que se espera que devuelva en la funcin de llamada, o
el compilador dar un warning.

Pequeos cambios

Volvamos al ejemplo anterior. Veamos qu sucede cuando hacemos pequeos

cambios:

Llamamos a la funcin con do_stuff (12.2, 13, 12345). No se produce

ningn error durante la compilacin, pues estamos trabajando con tipos
compatibles. La salida del programa es:
 There are 12 wings.
There are 13 feet.
There are 57 eyes.

There are 2 wings.

There are 1000 feet.
There are 2 eyes.

Llamamos a la funcin con slo dos parmetros: do_stuff (12.2, 13). El

compilador lanzar un mensaje de error:
11:error: In this statement, "do_stuff(1.22e1, 13)" supplies 2
arguments, but 3 are expected.
En la segunda llamada a la funcin, ponemos un & delante del nombre de
una de las variables, do_stuff (arm, &float, lookers). El mensaje de
error es el siguiente:
13:error:In this statement, "&lookers" is of type "pointer to
char", and may not be converted to "char".
Cambiemos, en el prototipo, void por int, int do_stuff(int wings, float
feet, char eyes);. Entonces, al compilar:
16:error:In this declaration, the type of "do_stuff" is not
compatible with the type of previous declaration of "do_stuff".

Si ahora modificamos adems el tipo devuelto en la declaracin de la

funcin, int do_stuff (int wings, float feet, char eyes) { ...},
obtenemos:
16:warning:Non-void function "do_stuff" does not contain a return
statement.

Podemos cambiar la declaracin de la funcin por:

void do_stuff (int, float, char);

Esto no dar ninguna diferencia respecto al programa original. Esto

demuestra que los nombres de las variables en el prototipo son tratados
como comentarios por el compilador de C++.

La funcin podra haber sido declarada de la siguiente forma:

void do_stuff (int wings, //Number of wings
float feet, //Number of feet
char eyes, //Number of eyes

Esto hace que la cabecera de la funcin sea autoexplicatoria. Sin embargo,

debe recordarse que los comentarios nunca deben usarse en lugar de
nombres significativos para las variables.

El uso de prototipos no supone coste alguno en tiempo ni en velocidad de

ejecucin. El prototipo se verifica durante la compilacin. Ralentiza sta, debido
a que es una comprobacin extra que el compilador debe hacer, pero es
despreciable el tiempo que necesita. El prototipo slo alarga el tamao del
cdigo.
Ejemplo:

#include <iostream>
using namespace std;

int mayor(int a, int b);

char mayor(char a, char b);
double mayor(double a, double b);

int main() {
cout << mayor('a', 'f') << endl;
cout << mayor(15, 35) << endl;
cout << mayor(10.254, 12.452) << endl;

return 0;
}

int mayor(int a, int b) {

if(a > b) return a; else return b;
}

char mayor(char a, char b) {

if(a > b) return a; else return b;
}

double mayor(double a, double b) {

if(a > b) return a; else return b;
}

Otro ejemplo:

#include <iostream>
using namespace std;

int mayor(int a, int b);

int mayor(int a, int b, int c);
int mayor(int a, int b, int c, int d);

int main() {
cout << mayor(10, 4) << endl;
cout << mayor(15, 35, 23) << endl;
cout << mayor(10, 12, 12, 18) << endl;

return 0;
}

int mayor(int a, int b) {

if(a > b) return a; else return b;
}

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

return mayor(mayor(a, b), c);
}

int mayor(int a, int b, int c, int d) {

return mayor(mayor(a, b), mayor(c, d));
}
In function `int main()\':

10: error: call of overloaded `mayor(int, int)\' is ambiguous

4: note: candidates are: int mayor(int, int)
5: note: int mayor(int, int, int)
6: note: int mayor(int, int, int, int)

11: error: call of overloaded `mayor(int, int, int)\' is ambiguous

5: note: candidates are: int mayor(int, int, int)
6: note: int mayor(int, int, int, int)

In function `int mayor(int, int, int)\':

25: error: call of overloaded `mayor(int&, int&)\' is ambiguous

18: note: candidates are: int mayor(int, int)
24: note: int mayor(int, int, int)
6: note: int mayor(int, int, int, int)

In function `int mayor(int, int, int, int)\':

30: error: call of overloaded `mayor(int&, int&)\' is ambiguous

18: note: candidates are: int mayor(int, int)
24: note: int mayor(int, int, int)
29: note: int mayor(int, int, int, int)

30: error: call of overloaded `mayor(int&, int&)\' is ambiguous

18: note: candidates are: int mayor(int, int)
24: note: int mayor(int, int, int)
29: note: int mayor(int, int, int, int)
#include <iostream>
using namespace std;

int mayor(int a=2, int b=-9) {

if(a > b) return a; else return b;
}

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

return mayor(mayor(a, b), c);
}

int mayor(int a, int b, int c, int d) {

return mayor(mayor(a, b), mayor(c, d));
}
int main() {
cout << mayor(10, 4) << endl;
cout << mayor(15, 35, 23) << endl;
cout << mayor(10, 12, 12, 18) << endl;
cout << mayor ()<<endl;
return 0;
}

#include <iostream>
#include <stdlib.h>
#include <limits.h>

using namespace std;

int mayor(int a, int b = INT_MIN, int c = INT_MIN, int d = INT_MIN );

int main() {
cout << mayor(5) << endl;
cout << mayor(15, 35, 23, 43) << endl;

system("pause");
return 0;
}

int mayor(int a, int b, int c, int d)

{
int numMay;

if( c == INT_MIN && d == INT_MIN )

( a > b )? numMay = a : numMay = b;
 else
numMay = mayor( mayor(a, b), mayor(c, d) );

return numMay;
}