C Standard Library stdarg.h

What You’ll Learn

<stdarg.h> lets you write functions that accept a variable number of arguments, like printf. The caller passes extra values after a fixed parameter; inside the function you use va_start, va_arg, and va_end to walk through them.

Definition and Usage

A variadic function ends its parameter list with ... (ellipsis). At least one named parameter must come before ...—often a count or format string that tells the function how many or what types follow.

The compiler does not type-check arguments after .... You must call va_arg with the correct type each time. Wrong types cause undefined behavior.

📝 Syntax

Include the header:

#include <stdarg.h>

Variadic function declaration

int sum(int count, ...);   /* count is last fixed arg before ... */

Macro and type reference

• va_list — type for the argument pointer (e.g. va_list ap;).
• va_start(ap, last) — initialize ap; last is the last named parameter.
• va_arg(ap, type) — fetch next argument as type.
• va_end(ap) — end traversal; required cleanup.
• va_copy(dest, src) — copy state (C99); call va_end on both when done.

Default argument promotion

• char and short → use va_arg(ap, int).
• float → use va_arg(ap, double).
• float literals in variadic calls are promoted to double.

Headers and linking

• #include <stdarg.h> — no special link flag.
• Compile: gcc program.c -std=c11 -o program

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Every variadic function needs a rule for how many arguments to read and of what type.

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

int sum(int count, ...) {
    int total = 0;
    va_list args;
    int i;

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

    return total;
}

int main(void) {
    printf("Sum of 3, 5, 7: %d\n", sum(3, 3, 5, 7));
    printf("Sum of 1..5: %d\n", sum(5, 1, 2, 3, 4, 5));

    return 0;
}

Sum of 3, 5, 7: 15
Sum of 1..5: 15

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

double average(int count, ...) {
    va_list args;
    double sum = 0.0;
    int i;

    va_start(args, count);
    for (i = 0; i < count; i++) {
        sum += va_arg(args, double);
    }
    va_end(args);

    return count > 0 ? sum / count : 0.0;
}

int main(void) {
    printf("Avg: %.2f\n", average(4, 10.0, 20.0, 30.0, 40.0));
    return 0;
}

Avg: 25.00

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

void print_words(const char *first, ...) {
    va_list args;
    const char *word = first;

    printf("Words:");
    while (word != NULL) {
        printf(" %s", word);
        if (word == first) {
            va_start(args, first);
            word = va_arg(args, const char *);
        } else {
            word = va_arg(args, const char *);
        }
    }
    va_end(args);
    printf("\n");
}

int main(void) {
    print_words("hello", "variadic", "world", (const char *)NULL);
    return 0;
}

Words: hello variadic world

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

void debug_log(const char *level, const char *fmt, ...) {
    va_list args;

    printf("[%s] ", level);
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
    printf("\n");
}

int main(void) {
    debug_log("INFO", "User %s logged in (id=%d)", "Alice", 42);
    debug_log("WARN", "Retries left: %d", 3);

    return 0;
}

[INFO] User Alice logged in (id=42)
[WARN] Retries left: 3

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

int max_int(int count, ...) {
    va_list args;
    int i, m;

    if (count <= 0) {
        return 0;
    }

    va_start(args, count);
    m = va_arg(args, int);
    for (i = 1; i < count; i++) {
        int v = va_arg(args, int);
        if (v > m) {
            m = v;
        }
    }
    va_end(args);

    return m;
}

int main(void) {
    printf("Max: %d\n", max_int(5, 3, 9, 1, 9, 4));
    return 0;
}

Max: 9

🚀 Common Use Cases

• printf / scanf family — format-driven variadic I/O.
• Logging libraries — log_info("...", ...) wrappers.
• Error reporting — warn(const char *fmt, ...).
• Math utilities — sum, min, max over many numbers.
• String builders — concatenate unknown number of C strings.
• Testing frameworks — assertion macros with optional messages.

📝 Notes

• You cannot pass ... to another function directly—use va_list and helpers like vprintf.
• Wrong va_arg type corrupts the walk and may crash.
• Reading past the last real argument is undefined behavior.
• C++ has safer alternatives (std::initializer_list, templates); C uses stdarg.
• va_end must run on every path, including early return.
• Variadic macros in C99 use __VA_ARGS__—different feature, often paired with logging.

⚡ Optimization

Variadic calls add slight overhead versus fixed parameters. For hot paths, pass an array and length instead of ten separate arguments. For logging, the cost is dominated by I/O, not va_arg itself.

💡 Best Practices