0Pricing
C Academy · Lección

Macros de stdarg

va_list, va_start, va_arg

Macros de stdarg es una lección gratuita de C Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

¿Qué son las funciones variádicas?

Una función variádica acepta una cantidad variable de argumentos. Ya ha utilizado una: printf puede recibir cualquier cantidad de valores.

C permite escribir funciones propias mediante las macros de <stdarg.h>.

#include <stdio.h>

int main(void) {
    printf("%d %d %d\n", 1, 2, 3);
    printf("%s\n", "any count of args");
    return 0;
}

Los puntos suspensivos

Declare una función variádica con ... (los puntos suspensivos) como último parámetro.

Antes debe haber al menos un parámetro con nombre, para que la función sepa dónde comienza la parte variable.

#include <stdio.h>
#include <stdarg.h>

void demo(int count, ...) {
    printf("This function takes %d extra args\n", count);
}

int main(void) {
    demo(3, 10, 20, 30);
    return 0;
}

Incluir stdarg.h

Para leer los argumentos variables necesita #include <stdarg.h>.

Este archivo define el tipo va_list y las macros va_start, va_arg y va_end.

#include <stdio.h>
#include <stdarg.h>

void show(int n, ...) {
    va_list args;
    va_start(args, n);
    va_end(args);
    printf("set up and cleaned up\n");
}

int main(void) {
    show(2, 5, 6);
    return 0;
}

va_list y va_start

Declare una variable va_list para hacer un seguimiento de la posición actual. Después, llame a va_start(list, last) pasando el último parámetro con nombre.

Esto coloca la lista en el primer argumento variable.

#include <stdio.h>
#include <stdarg.h>

void first(int count, ...) {
    va_list args;
    va_start(args, count);
    int value = va_arg(args, int);
    printf("first variadic arg = %d\n", value);
    va_end(args);
}

int main(void) {
    first(1, 99);
    return 0;
}

va_arg: leer valores

va_arg(list, type) devuelve el siguiente argumento y avanza la lista. Debe indicar el tipo exacto que se va a leer.

Cada llamada avanza un argumento.

#include <stdio.h>
#include <stdarg.h>

void three(int n, ...) {
    va_list args;
    va_start(args, n);
    int a = va_arg(args, int);
    int b = va_arg(args, int);
    int c = va_arg(args, int);
    printf("%d %d %d\n", a, b, c);
    va_end(args);
}

int main(void) {
    three(3, 7, 8, 9);
    return 0;
}

va_end: limpieza

Llame siempre a va_end(list) cuando termine de leer. Realiza cualquier tarea de limpieza que necesite la plataforma.

Olvidarlo provoca comportamiento indefinido en algunos sistemas.

#include <stdio.h>
#include <stdarg.h>

int add_two(int dummy, ...) {
    va_list args;
    va_start(args, dummy);
    int sum = va_arg(args, int) + va_arg(args, int);
    va_end(args);
    return sum;
}

int main(void) {
    printf("%d\n", add_two(0, 4, 6));
    return 0;
}

Saber cuántos argumentos hay

Las macros no pueden indicarle cuántos argumentos se pasaron. Debe comunicarlo usted mismo.

Un enfoque habitual es usar un parámetro inicial con el número, como en sum(3, a, b, c).

#include <stdio.h>
#include <stdarg.h>

int sum(int count, ...) {
    va_list args;
    va_start(args, count);
    int total = 0;
    for (int i = 0; i < count; i++)
        total += va_arg(args, int);
    va_end(args);
    return total;
}

int main(void) {
    printf("%d\n", sum(4, 1, 2, 3, 4));
    return 0;
}

Usar un valor centinela

Otra forma de marcar el final es usar un centinela: un valor especial de terminación que el llamador debe incluir, como -1 o NULL.

Repita el bucle hasta leer el centinela.

#include <stdio.h>
#include <stdarg.h>

int sum_until_neg(int first, ...) {
    va_list args;
    va_start(args, first);
    int total = first, v;
    while ((v = va_arg(args, int)) != -1)
        total += v;
    va_end(args);
    return total;
}

int main(void) {
    printf("%d\n", sum_until_neg(10, 20, 30, -1));
    return 0;
}

Promociones predeterminadas de argumentos

Los argumentos variádicos experimentan promociones predeterminadas: char y short se convierten en int, y float se convierte en double.

Por tanto, lea siempre los enteros pequeños como int y los valores de coma flotante como double con va_arg.

#include <stdio.h>
#include <stdarg.h>

void show_double(int n, ...) {
    va_list args;
    va_start(args, n);
    double d = va_arg(args, double);
    printf("%.2f\n", d);
    va_end(args);
}

int main(void) {
    show_double(1, 3.5f);
    return 0;
}

Copiar una va_list

Si necesita recorrer los argumentos dos veces, use va_copy(dest, src) para duplicar la lista antes de leerla.

No puede reutilizar una va_list después de va_end sin reiniciarla mediante va_start.

#include <stdio.h>
#include <stdarg.h>

void twice(int n, ...) {
    va_list a, b;
    va_start(a, n);
    va_copy(b, a);
    printf("%d %d\n", va_arg(a, int), va_arg(b, int));
    va_end(a);
    va_end(b);
}

int main(void) {
    twice(1, 42);
    return 0;
}

Calcular un promedio

Al combinar el patrón de conteo con la lectura de valores de coma flotante, podemos calcular el promedio de una lista de números pasados de forma variádica.

#include <stdio.h>
#include <stdarg.h>

double average(int count, ...) {
    va_list args;
    va_start(args, count);
    double sum = 0;
    for (int i = 0; i < count; i++)
        sum += va_arg(args, double);
    va_end(args);
    return sum / count;
}

int main(void) {
    printf("%.2f\n", average(3, 2.0, 4.0, 6.0));
    return 0;
}

Comprobación rápida

Compruebe su comprensión de las macros de stdarg.

Resumen

Ha aprendido el mecanismo variádico:

  • Declare con ... después de al menos un parámetro con nombre.
  • va_start(list, last) inicia, va_arg(list, type) lee y va_end(list) realiza la limpieza.
  • Las macros no conocen el número de argumentos: use un parámetro de conteo o un centinela.
  • Tenga en cuenta las promociones predeterminadas: lea los enteros pequeños como int y los valores de coma flotante como double.

Preguntas frecuentes

¿La lección «Macros de stdarg» es gratis?

Sí — el texto completo de «Macros de stdarg» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Macros de stdarg»?

va_list, va_start, va_arg Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Macros de stdarg»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Macros de stdarg
  2. Escritura de funciones similares a printf
  3. Consideraciones sobre la seguridad de tipos
  4. Ejemplos prácticos
← Volver a C Academy