El código fuente descárgalo aquí

Hace poco estuve buscando cierta información sobre C y recurrí a toda la bibliografía que he acumulado a lo largo de los años. Mientras buscaba me sorprendió ver que sólo dos de mis fuentes hablaban de cómo hacer funciones con una lista de argumentos de longitud variable. Una de ellas lo mencionaba, sin explicar nada, y me remitía a otra bibliografía. Menos mal que pude refugiarme en el único libro imprescindible para un programador de C: "El lenguaje de programación C" de Brian W. Kernigham y Dennis M. Ritchie.

Las funciones cuya lista de argumentos es variable pueden llegar a ser útiles en nuestros desarrollos, así que intentaremos explicar en qué consiste esta técnica de la que, aun sin conocerla, os aprovechais, pues es la base de la familia de funciones printf y scanf.

Podemos tener este número variable de argumentos gracias a la potencia y flexibilidad de C -donde podemos trabajar a nivel de direcciones de memoria-. Veremos en qué se basa y cómo nos ayuda una librería de C a crear este tipo de funciones. También programaremos un ejemplo para verlo más claro.


Fundamentos, demos gracias a la pila

Para entender cómo es posible crear este tipo de funciones es interesante comprender, aunque sólo sea de manera superficial, cómo funciona un compilador. En especial el mecanismo de llamadas a funciones.

Cuando el compilador traduce el código fuente a código máquina utiliza una pila para realizar ciertas tareas. La pila es, básicamente, una zona de almacenamiento temporal en memoria a la cual se hace referencia con un puntero. A través de este puntero se puede conocer sus contenidos. Cuando se llama a una función, se crea una nueva zona en ella un frame- donde se almacena cierta información, como por ejemplo, la dirección de retorno, las variables automáticas de la función, etc. A nosotros, lo que nos interesa es que en esa zona, también se copian los argumentos de la función.

En C los argumentos se pasan por valor, es decir, se hacen copias de los mismos, y por eso podemos usarlos como variables dentro del cuerpo de la función, sin miedo a que varíen fuera, y debemos trabajar con punteros cuando queremos el comportamiento contrario, es decir el paso de argumentos por referencia.

Veamos un caso sencillo. Tenemos la siguiente función y llamada:

1. va_list... es un tipo de dato que define un puntero a la lista de argumentos variable, se maneja a través de las macros siguientes.



2. void va_start(va_list pa, last)... macro que inicializa un puntero va_list, usando para ello last que es el nombre del último argumento antes de la lista variable, es decir, el último argumento cuyo tipo conoce la función.



3. tipo va_arg(va_list pa, tipo)... macro que devuelve el valor del siguente argumento -apuntado por el puntero pa y de tipo tipo-, que puede ser de cualquier tipo valido que pueda pasarse como argumento a una función. Además, esta macro, manipula pa haciendo que apunte al siguiente argumento de la lista para que invocaciones sucesivas devuelvan los valores del resto de argumentos.



4. void va_end(va_list pa)... macro que manipula un retorno normal de la función cuya lista de argumentos variable fue inicializada por va_start.

1. La lista variable siempre va al final de los argumentos.



2. Tiene que haber al menos un argumento definido -last-, para poder tener una referencia con la que acceder al resto de argumentos.



3. Dado que la dirección de last es utilizada por va_start no debe ser ni una variable register, ni una función, ni un array. La razón queda como ejercicio para el lector ¡vaya!, siempre quise escribir eso-.



4. Si no hay próximo argumento, o si tipo no es compatible con el tipo del próximo argumento, se producirán errores impredecibles al llamar a va_arg.



5. Ojo con los tipos. Tened en cuenta que por defecto C hace promoción de los parámetros pasados, así, si pasáis un float, este será promovido a double y la sentencia va_arg(pa,float) será incorrecta. Lo mismo con shorts, etc. Normalmente el compilador nos avisará de esto.



6. Las macros nos ayudan a trabajar de modo portable. No importa, por ejemplo, que un int tenga 32 o 16 bits. Las macros y el compilador se encargan de lidiar con la diferencia. Nosotros sólo vemos una lista de variables de distintos tipos.

1. Con un contador... uno de los argumentos fijos es un entero que indica el número de argumentos variables que debemos esperar. No permite indicar el tipo de los argumentos a menos que usemos un artificio adicional como indicarlos con constantes simbólicas-. Suele usarse con funciones que reciben argumentos de un tipo concreto.



2. Con una cadena de formateo... el estilo que usa la familia de funciones printf y scanf. La función recibe un argumento que indica de alguna manera la cantidad de argumentos variables esperados y el tipo de los mismos.

1. Función para sumar un número variable de dobles: usando un argumento para contar.
   
   Esta sencilla función toma un número variable de argumentos de tipo double para sumarlos. Tiene un argumento fijo: un entero operandos que indica la longitud de la lista variable.
   
   El bucle para recorrer dicha lista itera sobre el argumento operandos hasta que se hace cero, indicando que no quedan más. Este ejemplo es una implementación casi directa del pseudocódigo que vimos antes y no presenta mayores complicaciones.
   
   

   double multiSuma(int operandos, ...) {     double resultado = 0.0;     va_list pa;     va_start(pa, operandos);     while (operandos--) {         resultado += va_arg(pa, double);     }     va_end(pa);     return resultado; }




2. printf entre paréntesis: usando una cadena de formateo.
   
   Esta función parece más compleja, pero en el fondo es similar a la anterior. Vamos a hacer una implementación reducida de un printf sólo para cadenas y enteros- que rodea entre paréntesis las variables que escribe. La hemos llamado pprintf.
   
   Esta función usa una cadena de formateo, que en nuestro caso, tiene dos marcas, ?s para variables de tipo cadena y ?d para las de tipo entero.
   
   El tratamiento de la lista variable de argumentos es idéntico al realizado en el ejemplo anterior, salvo que ahora si que podemos usar tipos distintos véase el switch-. En este caso, la iteración no es sobre la lista de argumentos, sino sobre la cadena de formateo hemos definido un puntero char* p para recorrerla con aritmética de punteros-. Leemos cada carácter y lo escribimos en pantalla con putchar- a menos que sea un '?' que nos indica que busquemos un argumento más cuyo tipo se define en el siguiente carácter -*++p-.
   
   

   void pprintf(char *formato, ...) {     char *p;     va_list pa;     va_start(pa, formato);     for (p = formato; *p; p++) {         if (*p != '?') {             putchar (*p);             continue;         }         switch (*++p) {             case 'd':                 printf("(%d)", va_arg(pa, int));                 break;             case 's':                 printf("(%s)", va_arg(pa, char *));                 break;             default:                 putchar(*p);                 break;             }         }         va_end(pa); }




3. Probando lo anterior
   
   Ya para terminar escribimos un pequeño main para probar nuestras dos funciones:
   
   

   int main (void) {     printf("Resultado es %g", multiSuma(3, 0.3, 0.1, 0.2));     pprintf("Probemos a poner parentesis a una ?s y a un ?d", "cadena", 25);     return 0; }

   
   
   Como era de esperar, la salida es:
   
   

   Resultado es 0.6 Probemos a poner paréntesis a una (cadena) y a un (25)