Funciones en C++ C++ es un lenguaje que soporta totalmente el concepto llamado "Programacin Orientada a Objetos" y por lo tanto centra

su atencin en los objetos, no obstante, las funciones siguen siendo un componente central de todo programa y merecen atencin especial por las caractersticas nuevas agregadas por C++. Para informacin adicional puede consultar el artculo referente a las funciones en C. Primero la definicin: Una funcin es una seccin de cdigo independiente, con nombre, que ejecuta una tarea especfica y opcionalmente devuelve un valor al programa que la llam. Ahora veamos las partes de la definicin:

Una funcin tiene un nico nombre, al utilizar ste nombre en otras partes del programa se pueden ejecutar los enunciados contenidos en la funcin. A esto se le conoce como llamar a la funcin. Una funcin puede ser llamada desde otra funcin. Una funcin es independiente. Una funcin puede ejecutar sus tareas sin interferencia en de otras partes del programa. Una funcin ejecuta una tarea especfica. Esta es la parte fcil de la definicin. Una tarea es un trabajo discreto que su programa debe ejecutar como parte de su desempeo general, por ejemplo mandar una lnea de texto a impresin, ordenar una lista hacer un clculo matemtico. Una funcin opcionalmente devuelve un valor al programa que la llam. Cuando un programa llama a una funcin se ejecutan los enunciados contenidos en sta, si si programa lo requiere, stos enunciados pueden devolver un valor al programa que llam a la funcin.

Cuando un programa llama a una funcin, la ejecucin del cdigo salta a la posicin inicial definida por el nombre de la funcin, el programa ejecuta los enunciados contenidos en sta y posteriormente el programa que llam a la funcin contina en la lnea de cdigo siguiente. Una funcin bin diseada ejecuta una tarea especfica y fcil de entender. Es recomendable ante una tarea complicada, dividirla en mltiples funciones y entonces llamarlas a su debido momento. Volver al principio Declaracin y definicin de funciones Para utilizar una funcin en un programa se requiere en primer lugar declararla y despus definirla. La declaracin de la funcin le indica al compilador el nombre, el tipo de dato devuelto por la funcin

y los parmetros pasados a la funcin. A la declaracin de una funcin se le llama tambin el prototipo de la funcin. Cuando un programa llama a una funcin, el programa puede enviar hacia la funcin informacin en la forma de uno o msargumentos. Los argumentos son datos que la funcin puede necesitar para realizar su trabajo. Cuando la funcin termina su trabajo, la ejecucin del programa regresa a la lnea siguiente a la llamada a la funcin. Las funciones pueden enviar informacin al programa en la forma de un valor devuelto. El prototipo de una funcin provee al compilador con informacin de una funcin que ser definida posteriormente en el programa. El prototipo incluye, en este orden, el tipo de valor que la funcin devolver, el nombre de la funcin, el cual debe ser significativo del trabajo realizado por la funcin, y el tipo de variables utilizadas como argumentos que sern pasados a la funcin. Opcionalmente se puede incluir el nombre de las variables utilizadas como argumentos. El prototipo de una funcin, como todo enunciado ejecutable en un programa C++ debe terminarse con un smbolo de punto y coma. La definicin de una funcin es en s la funcin misma, est compuesta en su primer lnea de cdigo por el encabezado que debe ser idntico al prototipo de la funcin pero en ste caso no se utiliza el punto y coma, adems, al contrario del prototipo, donde es opcional incluir el nombre de las variables utilizadas como argumentos, en el encabezado de la funcin se debe incluir el nombre de las variables. Enseguida del encabezado est el cuerpo de la funcin que contiene, encerrados entre llaves, los enunciados ejecutables propios del trabajo a ejecutar por la funcin. Si la funcin devuelve un tipo de valor, ste se debe especificar al final del cuerpo de la funcin. Con toda la informacin reunida hasta este punto, estamos en condicin de escribir un programa que demuestre el prototipo y definicin de una funcin. Personalmente, primero escribo la definicin de la funcin y despus copio el encabezado de la misma para formar el prototipo, agregandole un punto y coma al final del enunciado. //********************************************************* // funcion1.cpp // Demuestra el prototipo y definicin de una funcin // (c)1999, Virgilio Gmez Negrete //********************************************************* #include <iostream.h>

// Prototipo de funciones void resta(int valor1, int valor2); int multiplica(int, int); // Funcin principal int main() { int numero1, numero2, resultado; cout << "Introduzca dos numeros" << endl; cin >> numero1 >> numero2; resta(numero1, numero2); // llama a la funcin "resta" resta(numero2, numero1); resultado = multiplica(numero1, numero2); cout << "La multiplicacion de los dos valores es: " << resultado << endl; return 0; } // Funcin resta void resta(int valor1, int valor2) { int sustraccion; // variable local sustraccion = valor1 - valor2; cout << "La resta de los dos valores es: " << sustraccion << endl; } // Funcin multiplica int multiplica(int valor1, int valor2) { int local; // variable local local = valor1 * valor2; return local; } En el cdigo funcion1.cpp se demuestra el uso bsico de las funciones en un programa C++, se aprecia en primer lugar el prototipo de dos funciones, una llamada resta y la otra propiamente llamada multiplica, utilizando nombres significativos para las funciones evitamos hacer comentarios redundantes y facilitamos la lectura del cdigo. En el prototipo de la funcin resta est especificada la palabra clave void lo que nos indica que la

funcinresta no devuelve valor alguno al programa que la llame, adems especifica dos variables de tipo int llamadas valor1 y valor2 para ser utilizadas como argumentos de la misma. Recuerde que en el prototipo de la funcin no es necesario incluir los nombres de las variables utilizadas como argumentos, esto se demuestra el el prototipo de la funcin llamadamultiplica que como est indicado, devuelve un valor de tipo int y requiere dos variables de tipo int como argumentos. Ya en el cuerpo de la funcin principal, main( ) el programa empieza declarando tres variables llamadas numero1, numero2 y resultado, le solicita introducir dos nmeros que son almacenados en las variables numero1 y numero2 y entonces llama en primer lugar a la funcin llamada resta( ) en la lnea 21 pasandole como argumentos las variables llamadasnumero1 y numero2. El programa entonces brinca a la parte del cdigo donde se encuentra la funcin llamada resta( ), en el encabezado de sta funcin vemos que se especifican para los argumentos de la funcin los nombres de dos variables, valor1 y valor2, en el encabezado de la funcin s es obligatorio especificar el nombre de las variables utilizadas como argumentos, se trata en efecto, de la declaracin de dos variables de tipo int que sern utilizadas en forma local por la funcin. Dentro del cuerpo de la funcin resta se declara una variable int llamada sustraccion en donde se almacena el resultado de restar los valores pasados como argumentos a la funcin, ste resultado se despliega en pantalla como parte de los enunciados ejecutables de la funcin. La funcin resta( ) no devuelve un valor al programa, as que una vez terminados los enunciados ejecutables de la misma la ejecucin del programa contina en la lnea 22, pero entonces el programa vuelve a llamar a la funcin resta( ), sin embargo observe que los argumentos estn invertidos con respecto a la llamada anterior, sto demuestra que los valores se pasan a la funcin en el orden en que son colocados en la llamada, de tal manera que en la segunda llamada a la funcin resta( ), valor1 toma el valor almacenado en la variable llamada numero2 y valor2 toma el valor almacenado en numero1. Despus de ejecutar por segunda vez la funcin resta( ) el programa contina en la lnea 24 en donde se asigna a la variable llamada resultado el valor devuelto por la funcin llamada multiplica( )a la que nuevamente le pasamos como argumentos los valores almacenados en las variables llamadas numero1 y numero2, esto es, el programa llama a la funcin multiplica( ) y ya en el cuerpo de sta funcin se declara una variable local de tipo int llamada local en donde se almacena el resultado de multiplicar los valores pasados a la funcin como argumentos, despus la funcin devuelve el valor almacenado en la

variable llamada local. Finalmente el programa despliega el valor almacenado en resultado y termina devolviendo al sistema el valor de 0. Volver al principio Variables locales y globales En C++ est permitido declarar variables en cualquier parte del cdigo fuente. Adems de pasar variables como parte del argumento de una funcin, tambin es posible declarar variables dentro del cuerpo de una funcin, a este tipo de variables se les llama locales ya que slo son tiles dentro del cuerpo de la funcin. Los parmetros utilizados en una funcin se consideran como variables de tipo local y se utilizan exactamente de la misma manera, como lo demuestra el fragmento de cdigo siguiente tomado del programa funcion1.cpp. int multiplica(int valor1, int valor2) { int local; // variable local local = valor1 * valor2; return local; } Los parmetros de la funcin, ambos de tipo int, llamados valor1 y valor2 son en efecto variables de alcance local al igual que la variable declarada como de tipo int llamada localdentro del cuarpo de la funcin multiplica( ). El alcance de una variable es simplemente el espacio dentro del cdigo fuente donde la variable puede ser utilizada, generalmente ste espacio est limitado por el par de llaves que sirven para encerrar las lneas de cdigo que conforman una funcin, generalmente, porque existen excepciones en C++ como es el caso de las variables utilizadas en el encabezado de un bucle for, sin embargo ste asunto puede tener variantes de acuerdo al nuevo estndar ANSI-C++ y por lo tanto algunos compiladores pueden limitar la existencia de stas variables estrictamente al cdigo contenido dentro del bucle for. A las variables que declaramos fuera del cuerpo de cualquier funcin se dice que tienen un alcance global y por lo tanto estas funciones estn disponibles para cualquier funcin del programa, incluyendo a main( ). Las variables locales que tienen el mismo nombre que las variables globales no cambian el valor de las

globales, sin embargo una variable local con el mismo nombre que una variable global oculta a la variable global. Los conceptos discutidos hasta este momento quedan demostrados en el siguiente programa: //********************************************************* // funcion2.cpp // Demuestra el alcance de las variables en C++ // (c)1999, Virgilio Gmez Negrete //********************************************************* #include <iostream.h> int global; // se inicializa automaticamente en cero

void funcion1(int parametro); int main() { int local1, i, global=30; cout << local1 << endl << endl; cout << "Introduzca un numero:" << endl; cin >> local1; cout << "Su numero es: " << local1 << endl; cout << endl; for(i=0; i<5; i++) { int local2; // vlida solo dentro del bucle local2 = i; cout << local1 << "\t"; cout << local2 << endl; } funcion1(local1); cout << cout << << "La variable \"global\" local vale: " global << endl; << "La variable \"global\" global vale: " ::global << endl;

global=45; cout << cout << << "La variable \"global\" local ahora vale: " global << endl; << "La variable \"global\" global vale: " ::global << endl;

//cout << local2 << endl; return 0; } void funcion1(int parametro) { global = global + parametro; } Estudiamos en primer lugar lo concerniente a las variables de alcance local llamadaslocal1 y local2, al igual que en C, las variables locales no son automticamente inicializadas con un valor igual a cero, por ste motivo el resultado desplegado en la lnea 17 es incierto, sin embargo al introducir un valor y almacenarlo en local1 tenemos la certeza de utilizar correctamente sta variable. Mas adelante, dentro del bucle for se declara otra variable de alcance local llamada local2 en la lnea 25, sta variable slo es til para los enunciados contenidos dentro del bucle, para demostrarlo puede quitar el comentario del enunciado de la lnea 44 y entonces el compilador generar un mensaje de error indicando que la variablelocal2 no ha sido declarada. Despus del bucle for llamamos a la funcin llamada funcion1( )pasndole como parmetro a la variable llamada local1, al hacer sto, el compilador en realidad crea una copia de la variable local1 y asigna el valor contenido en sta a la variable de alcance local llamda parametro, a ste proceso se le conoce como pasar un parmetro por valor. Ya dentro de la funcin, se suma el valor de parametro al de la variable de alcance global llamada global cambiando de sta forma el valor contenido en la variable de alcance global llamada global. Como habr observado, la funcin principal contiene a su vez una variable llamada global, sta por supuesto de alcance local. En las lneas 34 a la 44 se demuestra cmo una variable de alcance local oculta a una variable de alcance global que tienen el mismo nombre, adems se demuestra cmo utilizar el operador de alcance global(::) para tener acceso a una variable de alcance global oculta por una variable homnima de alcance local. Tambin se demuestra que una variable local no cambia el valor contenido en una variable de alcance global homnima. Volver al principio Parmetros por defecto Para cada parmetro declarado en el prototipo de la funcin y en su definicin, una llamada a la funcin debe pasar un valor del tipo

especfico, si la definicin de la funcin difiere si Usted comete un error al pasar un valor equivocado a la funcin, entonces el compilador generar un mensaje de error, la nica excepcin a la regla es si el prototipo de la funcin declara un valor por defecto para el parmetro. Un valor por defecto es el valor a utilizar en caso de que ninguno sea especificado, as, una declaracin de una funcin podra ser esta: char una_funcion(int defecto=120); En ste ejemplo se declara una funcin llamada una_funcion que toma un parmetro de tipo int, pero en caso de que no se incluya el parmetro necesario, entonces se utilizar el valor de 120 para ser utilizado por la funcin. Como no es absolutamente necesario utilizar nombres para los parmetros en el prototipo de una funcin, tambin podemos escribir la declaracin de una funcin de la siguiente manera: char una_funcion(int = 120); Es posible asignarle valores por defecto a todos los parmetros de una funcin, pero con una condicin, si cualquiera de los parmetros no lleva un valor por defecto, entonces los parmetros previos no podrn llevar un valor por defecto, por ejemplo, si el prototipo de una funcin es parecido a esto: char una_funcion(int parametro1, int parametro2, int parametro3); Usted puede asignar un valor por defecto a parametro2 solo si se le ha asignado un valor por defecto a parametro3. Usted solo podr asignar un valor por defecto aparametro1 solo si se le ha asignado valores por defecto a parametro2 y a parametro3. El siguiente programa demuestra lo dicho: //********************************************************* // funcion3.cpp // Demuestra parametros con valores por defecto // (c)1999, Virgilio Gmez Negrete //********************************************************* #include <iostream.h> int area_de_un_cubo(int longitud, int ancho = 50, int alto = 2);

int main() { int longitud = 100; int ancho = 25; int alto = 1; int area; area = area_de_un_cubo(longitud, ancho, alto); cout << "Area del primer cubo: " << area << endl; area = area_de_un_cubo(longitud, ancho); cout << "Area del segundo cubo: " << area << endl; area = area_de_un_cubo(longitud); cout << "Area del tercer cubo: " << area << endl; return 0; } area_de_un_cubo(int longitud, int ancho, int alto) { return (longitud * ancho * alto); } Volver al principio Nmero variable de argumentos Una de las caractersticas atractivas de C++ es la manera estricta en que verifica el tipo de parmetros utilizados en las funciones, sin embargo habr ocasiones en las que necesitemos una funcin con un nmero variable de parmetros, un ejemplo es la funcin Cprintf( ). El ANSI-C dispone de una serie de macros para determinar el nmero de argumentos utilizados en una funcin, stas macros estn definidas en el archivo de cabecera stdarg.h y tambin estn disponibles para C++ pero necesitamos una manera de evitar que el compilador C++ haga un chequeo estricto de los argumentos pasados a una funcin, esto se consigue utilizando tres puntos como se indica en la lnea 11 del siguiente programa: //********************************************************* // funcion4.cpp // Demuestra el uso de un nmero variable de argumentos // (c)1999, Virgilio Gmez Negrete //********************************************************* #include <iostream.h>

#include <stdarg.h> // Declara una funcin con un parmetro obligatorio void varios_argumentos(int numero, ...); int main() { int indice = 5; int uno = 1, dos = 2; varios_argumentos(uno, indice); varios_argumentos(3, indice, indice + dos, indice + uno); varios_argumentos(dos, 7, 3); return 0; } void varios_argumentos(int numero, ...) { va_list parametros; int indice2; // llama a la macro inicial va_start(parametros, numero); cout << "Los parametros son "; for (indice2 = 0 ; indice2 < numero ; indice2++) { // Determina el numero de parametros cout << va_arg(parametros, int) << " "; } cout << endl; // concluye la macro va_end(parametros); } El prototipo indicado en la lnea 11 dice que se requiere un parmetro de tipo int y a partir de ste el compilador no checar el tipo y nmero de argumentos pasados a la funcin llamada varios_argumentos( ). Observar que el programa consiste en tres llamadas a la funcin varios_argumentos( ) precisamente con diferente nmero de argumentos en cada llamada, Usted puede poner el nmero que desee de parmetros en la llamada a la funcin siempre y cuando el primer parmetro sea uno de tipo int, despus de sto es responsabilidad suya utilizar con cuidado el tipo y nmero de argumentos pasados a la funcin, se debe evitar escribir cdigo que resulte difcil de interpretar.

Volver al principio Sobrecarga de funciones C++ permite crear ms de una funcin con el mismo nombre las cuales se diferenciarn por el nmero de parmetros utilizados en el tipo de stos o en mbos. El valor regresado por las funciones puede ser igual diferente sin embargo dos o ms funciones con el mismo nombre y parmetros pero con valor de retorno diferente generar un mensaje de error por parte del compilador. Al proceso de llamar a ms de una funcin con el mismo nombre se le llama sobrecarga de funciones. El siguiente programa demuestra la sobrecarga de la funcin llamada polimorfo: //********************************************************* // funcion5.cpp // Demuestra la sobrecarga de funciones // (c)1999, Virgilio Gmez Negrete //********************************************************* #include <iostream.h> void polimorfo(float numero); void polimorfo(int numero); float polimorfo(char *texto, int numero); int main() { float valor; int valor2; char cadena[]="El nuevo valor es: "; cout << "Introduzca un valor flotante" << endl; cin >> valor; polimorfo(valor); valor2 = valor; polimorfo(valor2); valor2 = valor2 * 25; valor = polimorfo(cadena, valor2); polimorfo(valor); return 0; }

void polimorfo(float numero) { cout <<"El valor introducido es: " << numero << endl; } void polimorfo(int numero) { cout <<"La parte entera es: " << numero << endl; } float polimorfo(char *texto, int numero) { cout << texto << numero << endl; return (numero * 3.1416); } Este programa demuestra adems lo estricto que es C++ con respecto a checar el tipo de parmetros pasados a una funcin. En la lnea 24 asignamos a una variable de tipo intllamada valor2 el contenido de la variable de tipo float llamada valor. Truncar la parte fraccionaria de la variable llamada valor introducir un nmero entero no es suficiente para llamar a la funcin polimorfo(int numero), es necesario utilizar las variables de tipo adecuado, es decir, los parmetros formales declarados en el prototipo de las funciones. Volver al principio Recursividad Una funcin se puede llamar a s misma, a este proceso se le llama recursividad y puede ser directa e indirecta. Es directa cuando una funcin se llama a s misma. Ocurre recursividad indirecta cuando una funcin llama a otra funcin y sta ltima llama a la primera. Ambos tipos de recursividad se dan en dos formas, aquellas que eventualmente terminan y producen un resultado y el caso en que la recursividad nunca termina produciendo un bucle infinito y de aqu una falla en tiempo de ejecucin por falta de memoria. Algunos programadores piensan que este ltimo caso es divertido, sobre todo cuando le pasa a otra persona. :-) Es importante notar que cuando una funcin se llama a s misma, una nueva copia de sta funcin es la que se ejecuta. Las variables locales de la segunda funcin no interfieren con las variables locales de la primera, as mismo, las variables locales no se pueden afectar mutuamente. Tomemos como ejemplo un programa que calcule el factorial de un numero entero introducido por el usuario. El factorial est definido como el producto del nmero en cuestion por todos los

numeros enteros menores que l, de tal manera que el factorial de 5 = 5*4*3*2*1 = 120. El cdigo puede ser as: //********************************************************* // funcion7.cpp // Demuestra recursividad // (c)1999, Virgilio Gmez Negrete //********************************************************* #include <iostream.h> double factorial(int valor); int j=1; int main() { int numero; cout << "Introduzca un numero" << endl; cin >> numero; cout << endl; cout << numero << "! es igual a: " << factorial(numero) << endl; cout << "Se llamo a la funcion factorial " << j << " veces" << endl; return 0; } double factorial(int valor) { double resultado; if(valor<=1) return 1; else { resultado = (valor*factorial(valor-1)); j = j+1; } return resultado; } Como el factorial de un nmero suele dar como resultado un valor muy grande necesitamos utilizar una funcin de tipo double que tome

como parmetro un valor de tipoint, dicha funcin la hemos declarado con el nombre de factorial. Utilizamos una variable de alcance global llamada j para llevar un registro del nmero de veces en que la funcinfactorial( ) es llamada. El programa empieza solicitndole un nmero entero y despus llama por primera vez a la funcin factorial( ). La recursividad necesita una condicin para que en el momento oportuno detener la accin, por sta razn, la funcin factorial( ) determina en primer lugar si el valor pasado como parmetro de la funcin es igual a 1, en cuyo caso la funcin retorna 1. Si el valor del parmetro es mayor que 1, entonces la funcin factorial( )se llama a s misma tomando como parmetro el valor original menos uno, multiplicando ste valor por el valor del parmetro original y almacenando el resultado en la variable llamadaresultado, como se aprecia en la lnea 38 del programa. Cada vez que la funcin factorial( )sea llamada con un parmetro mayor que 1 se incrementa la variable global llamada j, sta variable debe tener mbito global porque necesitamos compartir el valor acumulado en la variable entre todas las copias que en determinado momento se hagan de la funcinfactorial( ), como resultado del fenmeno de recursividad. Un ejemplo adicional de recursividad lo encontrar en el programa llamado funcion6.cpp que est incluido en el archivo comprimido Cplus2.zip y que puede descargar al final de ste artculo.