Quien haya usado C++ alguna vez se ha encontrado con funciones como printf y scanf.
Esas funciones son especiales porque permiten ingresar un número arbitrario de argumentos (1 o más), primero vamos a explicar como trabaja una de éstas funciones.
int printf ( const char * format [ , argument , ...] );
Lo que nos interesa son los argumentos variables ([ , argument , ...]), los cuales pueden ser 0 o más y de cualquier tipo que la función pueda interpretar.
Por lo que las siguiente invocaciones son validas:
printf("Hola!");
printf("No se para que estoy", 2);
printf("Soy un entero: %d", 34);
printf("Soy una cadena: %s\nY yo un numero: %f", "No se porque me dicen \"cadena\"...", -23.55);Como podemos ver siempre debe estar el primer argumento (const char * format), porque internamente dá el comienzo del array de punteros que permite controlar la lista de argumentos consecuentes.
Ahora veamos como crear nuestra función que tome un entero y n enteros más:
#include <stdarg.h>
int sumar(int count, ...)
{
va_list pa;
int suma = 0;
va_start (pa, count);
while(count--)
suma+= va_arg (pa, int);
va_end (pa);
return suma;
}
Nuestra función sumar, suma count números y los retorna. La variable count debe contener la cantidad de argumentos variables que le pasamos la función. Prueben que pasa no le pasamos argumentos variables y count es mayor que cero (Por ejemplo: sumar(34)
.
Aqui el motor de dicha mágia es la cabecera stdarg.h la cual mantiene un conjunto de macros que nos posibilitan crear funciones de éste tipo.
Lo segundo que vemos es el prototipo de la función (int sumar(int count, ...)), y sus puntos suspensivos. Ellos indican que a partir de esa posición (el segundo parámetro) el número de parámetros es variable, es decir, le podemos enviar cero o más valores (o variables).
Luego va_list es un puntero a una "lista" que contiene una referencia a los argumentos variables. Para saber donde comienzan a llegar éstos argumentos se le debe indicar cual es el último argumento fijo (va_start), en nuestro caso es count. Para ir obteniendo los valores de los argumentos variables utilizamos va_arg(*lista, tipodelargumento), el cual nos retorna el valor del argumento siguiente y lo interpreta al tipodeargumento indicado (ésto puede ser un problema en tiempo de ejecución, ya hablaremos de ello).
Y por último liberamos los recursos de nuestra lista con va_end.
Como habiamos dicho antes, necesitamos conocer la cantidad y el tipo de los argumentos que nos llegan, y básicamente hay dos maneras: con un contador (y asumiendo un tipo de dato predeterminado, como es nuestro caso (enteros)), o con una cadena de formato, que es como trabaja printf y scanf.
La cadena de formato nos indica la cantidad y el tipo de los argumentos variables enviados a la función, por ejemplo:
"Soy una cadena: %s\nY yo un numero: %f"
Asume que llegan 2 argumentos: %s y %f
Y que esos argumentos son: cadena (%s) y real (%f) respectivamente.
De esa manera se puede crear un algoritmo que sepa identificar el tipo de argumento que llega y actue en consecuencia.
Ésto es solo un vistazo, muy básico, sobre funciones con número arbitrario de parámetros.
Saludos.
PD: Que pasaría si tenemos argumentos fijos con valores por defecto? si quieren lo discutimos.
