Variadic functions are one of C's most powerful yet misunderstood features. These functions can accept a variable number of arguments, allowing developers to create flexible interfaces like printf() and scanf(). For C programmers, understanding variadic functions is essential for building logging systems, custom formatting functions, mathematical libraries, and any API that needs to handle an unknown number of parameters.

What are Variadic Functions?

Variadic functions (from "variable arguments") are functions that can accept a variable number of arguments. The most famous examples are printf() and scanf() from the standard library. In C, variadic functions are implemented using the <stdarg.h> header, which provides macros and types to access the variable argument list safely.

Why Variadic Functions are Essential in C

1. Flexible Interfaces: Create functions like printf() that accept any number of arguments
2. Logging Systems: Build logging functions that handle different message formats
3. Mathematical Operations: Implement sum, average, min, max for any number of values
4. Formatting Functions: Create custom formatters for complex data types
5. API Design: Provide cleaner interfaces than passing arrays or structures
6. Wrapper Functions: Build safe wrappers around existing variadic functions

The stdarg.h Interface

#include <stdio.h>
#include <stdarg.h>  // Required for variadic functions
// Key macros and types:
// va_list    - Type to hold information about variable arguments
// va_start() - Initialize va_list to access arguments
// va_arg()   - Retrieve next argument of specified type
// va_end()   - Clean up va_list
// va_copy()  - Copy va_list (C99)

Basic Variadic Function Example

#include <stdio.h>
#include <stdarg.h>
// Simple function that sums a variable number of integers
// First argument: count of numbers to sum
// Remaining arguments: the numbers to sum
int sum(int count, ...) {
va_list args;
int total = 0;
// Initialize va_list to access variable arguments
va_start(args, count);
// Retrieve each argument
for (int i = 0; i < count; i++) {
total += va_arg(args, int);
}
// Clean up
va_end(args);
return total;
}
int main() {
printf("=== Basic Variadic Function ===\n\n");
// Call with different numbers of arguments
printf("sum(3, 10, 20, 30) = %d\n", sum(3, 10, 20, 30));
printf("sum(5, 1, 2, 3, 4, 5) = %d\n", sum(5, 1, 2, 3, 4, 5));
printf("sum(1, 100) = %d\n", sum(1, 100));
printf("sum(0) = %d\n", sum(0));  // No numbers to sum
return 0;
}

Understanding Variadic Function Mechanics

#include <stdio.h>
#include <stdarg.h>
// Function that demonstrates how variadic arguments work
void demonstrateVariadic(const char *format, ...) {
printf("=== Variadic Mechanics ===\n\n");
va_list args;
// Initialize - must know the last named parameter
va_start(args, format);
printf("format string: \"%s\"\n", format);
printf("Arguments are stored on the stack\n");
printf("va_list is an opaque type that points to arguments\n\n");
// Demonstrate argument types and sizes
printf("va_start initializes args to point after 'format'\n");
printf("va_arg(args, type) retrieves next argument and advances\n");
printf("va_end cleans up\n\n");
// Access arguments based on format string
for (const char *p = format; *p; p++) {
if (*p == 'd') {
int i = va_arg(args, int);
printf("  int argument: %d\n", i);
} else if (*p == 'f') {
double d = va_arg(args, double);  // float promoted to double
printf("  double argument: %f\n", d);
} else if (*p == 'c') {
char c = va_arg(args, int);  // char promoted to int
printf("  char argument: '%c'\n", c);
} else if (*p == 's') {
char *s = va_arg(args, char*);
printf("  string argument: \"%s\"\n", s);
}
}
va_end(args);
}
int main() {
demonstrateVariadic("dffcs", 42, 3.14, 2.718, 'A', "Hello");
return 0;
}

Building a Flexible Logging System

#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <string.h>
// Log levels
typedef enum {
LOG_DEBUG,
LOG_INFO,
LOG_WARNING,
LOG_ERROR,
LOG_CRITICAL
} LogLevel;
const char* logLevelNames[] = {
"DEBUG",
"INFO",
"WARNING",
"ERROR",
"CRITICAL"
};
// Global log level (can be changed at runtime)
LogLevel currentLogLevel = LOG_INFO;
// File for logging (NULL = console)
FILE *logFile = NULL;
// Get current timestamp string
void getTimestamp(char *buffer, size_t size) {
time_t now = time(NULL);
struct tm *tm_info = localtime(&now);
strftime(buffer, size, "%Y-%m-%d %H:%M:%S", tm_info);
}
// Core logging function
void logMessage(LogLevel level, const char *file, int line, 
const char *function, const char *format, ...) {
if (level < currentLogLevel) {
return;  // Skip messages below current log level
}
char timestamp[32];
getTimestamp(timestamp, sizeof(timestamp));
// Print prefix
if (logFile) {
fprintf(logFile, "[%s] %s:%d %s() - %s: ", 
timestamp, file, line, function, logLevelNames[level]);
} else {
printf("[%s] %s:%d %s() - %s: ", 
timestamp, file, line, function, logLevelNames[level]);
}
// Handle variable arguments
va_list args;
va_start(args, format);
if (logFile) {
vfprintf(logFile, format, args);
fprintf(logFile, "\n");
fflush(logFile);
} else {
vprintf(format, args);
printf("\n");
}
va_end(args);
}
// Convenience macros (add file/line/function automatically)
#define LOG_DEBUG(...)   logMessage(LOG_DEBUG, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define LOG_INFO(...)    logMessage(LOG_INFO, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define LOG_WARNING(...) logMessage(LOG_WARNING, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define LOG_ERROR(...)   logMessage(LOG_ERROR, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define LOG_CRITICAL(...) logMessage(LOG_CRITICAL, __FILE__, __LINE__, __func__, __VA_ARGS__)
// Function to set log level
void setLogLevel(LogLevel level) {
currentLogLevel = level;
LOG_INFO("Log level set to %s", logLevelNames[level]);
}
// Function to enable file logging
int enableFileLogging(const char *filename) {
if (logFile) {
fclose(logFile);
}
logFile = fopen(filename, "a");
if (logFile) {
LOG_INFO("File logging enabled: %s", filename);
return 1;
}
return 0;
}
// Example usage
int main() {
printf("=== Flexible Logging System ===\n\n");
// Test with console logging
LOG_DEBUG("This is a debug message");  // Won't show (level too low)
LOG_INFO("Application started");
LOG_WARNING("Low memory: %d bytes free", 1024 * 1024);
LOG_ERROR("Failed to open file: %s", "config.txt");
LOG_CRITICAL("System shutting down: %s", "fatal error");
printf("\nChanging log level to DEBUG:\n");
setLogLevel(LOG_DEBUG);
LOG_DEBUG("Now debug messages appear");
LOG_INFO("Still logging info");
// Test file logging
printf("\nEnabling file logging...\n");
if (enableFileLogging("app.log")) {
LOG_INFO("This message goes to file");
LOG_ERROR("Error with code: %d", 404);
}
// Clean up
if (logFile) {
fclose(logFile);
}
return 0;
}

Mathematical Functions with Variable Arguments

#include <stdio.h>
#include <stdarg.h>
#include <float.h>
#include <math.h>
// ============================================================
// VARIADIC MATH FUNCTIONS
// ============================================================
// Sum of any number of doubles
double vsum(int count, ...) {
va_list args;
double total = 0.0;
va_start(args, count);
for (int i = 0; i < count; i++) {
total += va_arg(args, double);
}
va_end(args);
return total;
}
// Average of any number of doubles
double vaverage(int count, ...) {
if (count <= 0) return 0.0;
va_list args;
double total = 0.0;
va_start(args, count);
for (int i = 0; i < count; i++) {
total += va_arg(args, double);
}
va_end(args);
return total / count;
}
// Find maximum value
double vmax(int count, ...) {
if (count <= 0) return -DBL_MAX;
va_list args;
double max = -DBL_MAX;
va_start(args, count);
for (int i = 0; i < count; i++) {
double val = va_arg(args, double);
if (val > max) max = val;
}
va_end(args);
return max;
}
// Find minimum value
double vmin(int count, ...) {
if (count <= 0) return DBL_MAX;
va_list args;
double min = DBL_MAX;
va_start(args, count);
for (int i = 0; i < count; i++) {
double val = va_arg(args, double);
if (val < min) min = val;
}
va_end(args);
return min;
}
// Standard deviation
double vstddev(int count, ...) {
if (count <= 1) return 0.0;
va_list args;
double sum = 0.0;
double sum_sq = 0.0;
// First pass: calculate sum
va_start(args, count);
for (int i = 0; i < count; i++) {
double val = va_arg(args, double);
sum += val;
}
va_end(args);
double mean = sum / count;
// Second pass: calculate squared differences
va_start(args, count);
for (int i = 0; i < count; i++) {
double val = va_arg(args, double);
double diff = val - mean;
sum_sq += diff * diff;
}
va_end(args);
return sqrt(sum_sq / (count - 1));
}
// Variadic with sentinel value (terminator)
double vsum_sentinel(double first, ...) {
va_list args;
double total = first;
va_start(args, first);
while (1) {
double val = va_arg(args, double);
if (val == -1.0) break;  // Sentinel value
total += val;
}
va_end(args);
return total;
}
int main() {
printf("=== Variadic Math Functions ===\n\n");
printf("vsum(5, 1.0, 2.0, 3.0, 4.0, 5.0) = %.2f\n", 
vsum(5, 1.0, 2.0, 3.0, 4.0, 5.0));
printf("vaverage(4, 10.0, 20.0, 30.0, 40.0) = %.2f\n", 
vaverage(4, 10.0, 20.0, 30.0, 40.0));
printf("vmax(6, 3.14, 2.71, 1.41, 1.61, 2.24, 3.33) = %.2f\n", 
vmax(6, 3.14, 2.71, 1.41, 1.61, 2.24, 3.33));
printf("vmin(6, 3.14, 2.71, 1.41, 1.61, 2.24, 3.33) = %.2f\n", 
vmin(6, 3.14, 2.71, 1.41, 1.61, 2.24, 3.33));
printf("vstddev(5, 10.0, 12.0, 23.0, 23.0, 16.0) = %.2f\n", 
vstddev(5, 10.0, 12.0, 23.0, 23.0, 16.0));
printf("\nSentinel-terminated sum: ");
printf("vsum_sentinel(1.0, 2.0, 3.0, 4.0, -1.0) = %.2f\n",
vsum_sentinel(1.0, 2.0, 3.0, 4.0, -1.0));
return 0;
}

String Formatting Functions

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
// ============================================================
// CUSTOM STRING FORMATTING FUNCTIONS
// ============================================================
// Safe string concatenation with variable arguments
char* vstrcat(const char *first, ...) {
va_list args;
const char *current;
size_t total_len = 0;
// First pass: calculate total length
va_start(args, first);
current = first;
while (current != NULL) {
total_len += strlen(current);
current = va_arg(args, const char*);
}
va_end(args);
// Allocate result string
char *result = malloc(total_len + 1);
if (result == NULL) return NULL;
// Second pass: concatenate strings
char *ptr = result;
va_start(args, first);
current = first;
while (current != NULL) {
size_t len = strlen(current);
memcpy(ptr, current, len);
ptr += len;
current = va_arg(args, const char*);
}
va_end(args);
*ptr = '\0';
return result;
}
// Build a string with printf-style formatting
char* vprintf_alloc(const char *format, ...) {
va_list args;
// First, determine required size
va_start(args, format);
int size = vsnprintf(NULL, 0, format, args);
va_end(args);
if (size < 0) return NULL;
// Allocate buffer
char *buffer = malloc(size + 1);
if (buffer == NULL) return NULL;
// Format the string
va_start(args, format);
vsnprintf(buffer, size + 1, format, args);
va_end(args);
return buffer;
}
// Custom printf that writes to a file
int vfprintf_custom(FILE *stream, const char *format, ...) {
va_list args;
va_start(args, format);
int result = vfprintf(stream, format, args);
va_end(args);
return result;
}
// Custom printf that writes to a string buffer with bounds checking
int vsnprintf_custom(char *buffer, size_t size, const char *format, ...) {
va_list args;
va_start(args, format);
int result = vsnprintf(buffer, size, format, args);
va_end(args);
return result;
}
// Format a string with a table of values
char* format_table(const char *headers[], int header_count, 
const char *format, ...) {
// This is simplified - in real code you'd process each row
va_list args;
va_start(args, format);
// Calculate total size needed
int size = 1024;  // Guess
char *buffer = malloc(size);
// Print headers
int pos = 0;
for (int i = 0; i < header_count; i++) {
pos += snprintf(buffer + pos, size - pos, 
"| %-15s ", headers[i]);
}
pos += snprintf(buffer + pos, size - pos, "|\n");
// Print separator
for (int i = 0; i < header_count; i++) {
pos += snprintf(buffer + pos, size - pos, 
"|-----------------");
}
pos += snprintf(buffer + pos, size - pos, "|\n");
// Use vsnprintf for the data row
pos += vsnprintf(buffer + pos, size - pos, format, args);
va_end(args);
return buffer;
}
int main() {
printf("=== Custom String Formatting ===\n\n");
// String concatenation
char *result = vstrcat("Hello", " ", "World", "!", " How", " are", " you?", NULL);
if (result) {
printf("vstrcat result: \"%s\"\n", result);
free(result);
}
// Dynamic allocation with printf
char *formatted = vprintf_alloc("The answer is %d (in hex: 0x%X)", 42, 42);
if (formatted) {
printf("vprintf_alloc: \"%s\"\n", formatted);
free(formatted);
}
// Table formatting (simplified demo)
const char *headers[] = {"Name", "Age", "Salary"};
char *table = format_table(headers, 3, 
"| %-15s | %-15d | %-15.2f |\n", "John Doe", 30, 75000.50);
if (table) {
printf("\nTable:\n%s", table);
free(table);
}
return 0;
}

Variadic Function Wrappers and Safety

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <errno.h>
// ============================================================
// SAFE WRAPPERS AND ERROR HANDLING
// ============================================================
// Safe wrapper for printf that checks return value
int safe_printf(const char *format, ...) {
va_list args;
va_start(args, format);
int result = vprintf(format, args);
va_end(args);
if (result < 0) {
fprintf(stderr, "Error writing to stdout: %s\n", 
strerror(errno));
}
return result;
}
// Safe wrapper for fprintf with automatic flushing
int safe_fprintf(FILE *stream, const char *format, ...) {
va_list args;
va_start(args, format);
int result = vfprintf(stream, format, args);
va_end(args);
if (result < 0) {
fprintf(stderr, "Error writing to stream: %s\n", 
strerror(errno));
} else {
fflush(stream);  // Ensure data is written
}
return result;
}
// Function that retries on partial write
int retry_printf(int max_retries, const char *format, ...) {
va_list args;
int result = -1;
for (int attempt = 0; attempt < max_retries; attempt++) {
va_start(args, format);
result = vprintf(format, args);
va_end(args);
if (result >= 0) break;
if (errno != EINTR) {  // Don't retry on non-interrupt errors
break;
}
}
return result;
}
// Variadic function with type checking (using _Generic in C11)
#define checked_printf(format, ...) \
_Generic((format), \
char*: checked_printf_impl, \
const char*: checked_printf_impl \
)(format, __VA_ARGS__)
int checked_printf_impl(const char *format, ...) {
// In real code, you'd parse format string and check argument types
va_list args;
va_start(args, format);
int result = vprintf(format, args);
va_end(args);
return result;
}
// Debug function that logs to multiple destinations
void multi_log(FILE *dest1, FILE *dest2, const char *format, ...) {
va_list args1, args2;
va_start(args1, format);
va_copy(args2, args1);  // Copy for second destination
vfprintf(dest1, format, args1);
vfprintf(dest2, format, args2);
va_end(args2);
va_end(args1);
}
int main() {
printf("=== Safe Wrappers and Error Handling ===\n\n");
safe_printf("This is a safe printf: %d, %.2f\n", 42, 3.14159);
// Test multi-logging
FILE *log = fopen("log.txt", "w");
if (log) {
multi_log(stdout, log, "Logging to both: %s\n", "Hello World");
fclose(log);
}
// Demonstrate va_copy
printf("\nva_copy allows using same args multiple times\n");
return 0;
}

Advanced Techniques: Function Pointers with Variadic Functions

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
// ============================================================
// FUNCTION POINTERS WITH VARIADIC FUNCTIONS
// ============================================================
// Define a function pointer type for variadic functions
typedef int (*VariadicPrinter)(const char *, ...);
// Functions that match the signature
int console_printer(const char *format, ...) {
va_list args;
va_start(args, format);
int result = vprintf(format, args);
va_end(args);
return result;
}
int file_printer(const char *format, ...) {
// In real code, you'd have a file handle somewhere
va_list args;
va_start(args, format);
int result = vfprintf(stdout, format, args);  // Simplified
va_end(args);
return result;
}
int string_printer(const char *format, ...) {
static char buffer[1024];
va_list args;
va_start(args, format);
int result = vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
printf("String printer buffer: %s", buffer);
return result;
}
// Function that uses a variadic function pointer
void print_with_strategy(VariadicPrinter printer, const char *format, ...) {
va_list args;
va_start(args, format);
// Need to pass args to the function pointer - tricky!
// Can't directly pass va_list to variadic function
// Solution: Create a wrapper that takes va_list
// For demonstration, we'll call the printer directly
// (This only works if the printer uses vprintf internally)
// Better: Have printer functions accept va_list
va_end(args);
printf("Note: This requires special handling - see v* versions\n");
}
// Better approach: Use functions that accept va_list
typedef int (*VPrinter)(const char *, va_list);
int vconsole_printer(const char *format, va_list args) {
return vprintf(format, args);
}
int vfile_printer(const char *format, va_list args) {
return vfprintf(stdout, format, args);  // Simplified
}
int vstring_printer(const char *format, va_list args) {
static char buffer[1024];
return vsnprintf(buffer, sizeof(buffer), format, args);
}
void print_with_vstrategy(VPrinter printer, const char *format, ...) {
va_list args;
va_start(args, format);
printer(format, args);
va_end(args);
}
int main() {
printf("=== Function Pointers with Variadic Functions ===\n\n");
// Using va_list versions (cleaner)
printf("Using v* functions:\n");
print_with_vstrategy(vconsole_printer, "Hello %s, number %d\n", 
"World", 42);
// Array of function pointers
VPrinter printers[] = {vconsole_printer, vfile_printer, vstring_printer};
const char *names[] = {"Console", "File", "String"};
printf("\nUsing array of function pointers:\n");
for (int i = 0; i < 3; i++) {
printf("  %s: ", names[i]);
print_with_vstrategy(printers[i], "value = %d\n", i * 100);
}
return 0;
}

Building a Variadic Function with Format String Parsing

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
// ============================================================
// CUSTOM FORMATTER WITH FORMAT STRING PARSING
// ============================================================
// Simple custom formatter that handles %d, %f, %s
int my_printf(const char *format, ...) {
va_list args;
int count = 0;
va_start(args, format);
for (const char *p = format; *p; p++) {
if (*p != '%') {
putchar(*p);
count++;
continue;
}
// Handle format specifier
p++;  // Skip '%'
switch (*p) {
case 'd': {
int i = va_arg(args, int);
count += printf("%d", i);
break;
}
case 'f': {
double d = va_arg(args, double);
count += printf("%f", d);
break;
}
case 's': {
char *s = va_arg(args, char*);
count += printf("%s", s);
break;
}
case 'c': {
// char promoted to int in varargs
int c = va_arg(args, int);
putchar(c);
count++;
break;
}
case '%':
putchar('%');
count++;
break;
default:
putchar('%');
putchar(*p);
count += 2;
break;
}
}
va_end(args);
return count;
}
// More advanced formatter with width and precision
int advanced_printf(const char *format, ...) {
va_list args;
int count = 0;
va_start(args, format);
for (const char *p = format; *p; p++) {
if (*p != '%') {
putchar(*p);
count++;
continue;
}
p++;  // Skip '%'
// Parse flags (simplified)
int left_align = 0;
int width = 0;
int precision = -1;
// Check for left align flag
if (*p == '-') {
left_align = 1;
p++;
}
// Parse width
while (isdigit(*p)) {
width = width * 10 + (*p - '0');
p++;
}
// Parse precision
if (*p == '.') {
p++;
precision = 0;
while (isdigit(*p)) {
precision = precision * 10 + (*p - '0');
p++;
}
}
// Handle format specifier
switch (*p) {
case 'd': {
int i = va_arg(args, int);
if (width > 0) {
count += printf("%*d", left_align ? -width : width, i);
} else {
count += printf("%d", i);
}
break;
}
case 'f': {
double d = va_arg(args, double);
if (width > 0 && precision >= 0) {
char fmt[32];
sprintf(fmt, "%%%s%d.%df", 
left_align ? "-" : "", width, precision);
count += printf(fmt, d);
} else {
count += printf("%f", d);
}
break;
}
case 's': {
char *s = va_arg(args, char*);
if (width > 0) {
count += printf("%*s", left_align ? -width : width, s);
} else {
count += printf("%s", s);
}
break;
}
default:
putchar('%');
putchar(*p);
count += 2;
break;
}
}
va_end(args);
return count;
}
int main() {
printf("=== Custom Formatter ===\n\n");
printf("Standard printf: ");
printf("Hello %s, %d, %.2f\n", "World", 42, 3.14159);
printf("my_printf:       ");
my_printf("Hello %s, %d, %f\n", "World", 42, 3.14159);
printf("\nAdvanced formatting:\n");
advanced_printf("|%10s|%10d|%10.2f|\n", "right", 123, 45.67);
advanced_printf("|%-10s|%-10d|%-10.2f|\n", "left", 123, 45.67);
return 0;
}

Limitations and Pitfalls

#include <stdio.h>
#include <stdarg.h>
// ============================================================
// COMMON PITFALLS AND LIMITATIONS
// ============================================================
// PITFALL 1: No type safety
void unsafe_function(int count, ...) {
va_list args;
va_start(args, count);
// If caller passes wrong type, behavior is undefined
for (int i = 0; i < count; i++) {
int val = va_arg(args, int);  // Assumes all are ints
printf("%d ", val);
}
va_end(args);
}
// PITFALL 2: Default argument promotions
void demonstrate_promotions(const char *types, ...) {
va_list args;
va_start(args, types);
printf("Default argument promotions:\n");
printf("  - char promotes to int\n");
printf("  - float promotes to double\n");
printf("  - short promotes to int\n\n");
for (const char *p = types; *p; p++) {
if (*p == 'c') {
// Must read char as int due to promotion
int c = va_arg(args, int);
printf("  char argument: '%c' (as int %d)\n", c, c);
} else if (*p == 'f') {
// Must read float as double
double d = va_arg(args, double);
printf("  float argument: %f (as double)\n", d);
}
}
va_end(args);
}
// PITFALL 3: No way to know argument count
// Must have convention: count parameter, sentinel, or format string
// PITFALL 4: Cannot pass va_list to another variadic function directly
void wrapper(const char *format, ...) {
va_list args;
va_start(args, format);
// This WON'T work correctly
// printf(format, args);  // WRONG!
// Must use vprintf variant
vprintf(format, args);
va_end(args);
}
// PITFALL 5: va_list cannot be reused without va_copy
void multiple_use(const char *format, ...) {
va_list args1, args2;
va_start(args1, format);
va_copy(args2, args1);  // Must copy for second use
printf("First use: ");
vprintf(format, args1);
printf("\nSecond use: ");
vprintf(format, args2);
va_end(args2);
va_end(args1);
}
// PITFALL 6: Macros with variable arguments (C99)
#define DEBUG_PRINT(...) printf("DEBUG: " __VA_ARGS__)
// PITFALL 7: No runtime checking
// Consider adding validation macros
int main() {
printf("=== Common Pitfalls ===\n\n");
// Pitfall 1: Type safety
printf("Pitfall 1: No type safety\n");
unsafe_function(3, 10, 20, 30);  // OK
// unsafe_function(3, 10, 20.5, "hello");  // Undefined behavior!
// Pitfall 2: Default promotions
printf("\nPitfall 2: Default promotions\n");
char c = 'A';
float f = 3.14f;
demonstrate_promotions("cf", c, f);
// Pitfall 4: Wrapper
printf("\nPitfall 4: Wrapper function\n");
wrapper("Wrapper example: %s %d\n", "Hello", 42);
// Pitfall 5: Multiple use
printf("\nPitfall 5: Multiple use with va_copy\n");
multiple_use("%d %.1f %s\n", 10, 3.14, "test");
// Pitfall 6: Variadic macros
DEBUG_PRINT("Value = %d\n", 100);
return 0;
}

Best Practices

#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
// ============================================================
// BEST PRACTICES FOR VARIADIC FUNCTIONS
// ============================================================
// 1. Always provide a non-variadic version that takes va_list
int v_my_function(const char *format, va_list args) {
// Implementation here
return vprintf(format, args);
}
int my_function(const char *format, ...) {
va_list args;
va_start(args, format);
int result = v_my_function(format, args);
va_end(args);
return result;
}
// 2. Document argument expectations clearly
/**
* Calculate sum of integers.
* @param count Number of integers to sum (must be >= 0)
* @param ... Variable number of integers to sum
* @return Sum of all integers
*/
int sum_ints(int count, ...) {
assert(count >= 0);
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;
}
// 3. Use sentinel values for termination
int sum_ints_sentinel(int first, ...) {
va_list args;
va_start(args, first);
int total = first;
while (1) {
int next = va_arg(args, int);
if (next == 0) break;  // Sentinel
total += next;
}
va_end(args);
return total;
}
// 4. Provide type-safe wrappers using macros (C11 _Generic)
#define safe_sum(x, ...) _Generic((x), \
int: sum_ints, \
double: sum_doubles \
)(x, __VA_ARGS__)
// 5. Always use va_end (even on error paths)
int robust_function(const char *format, ...) {
va_list args;
va_start(args, format);
int result = -1;
FILE *f = fopen("test.txt", "w");
if (f) {
result = vfprintf(f, format, args);
fclose(f);
}
va_end(args);  // Always called
return result;
}
// 6. Check argument count when possible
#define MAX_ARGS 10
int bounded_sum(int count, ...) {
if (count < 0 || count > MAX_ARGS) {
fprintf(stderr, "Invalid argument count: %d\n", count);
return 0;
}
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;
}
// 7. Provide default values for missing arguments
int flexible_function(int required, ...) {
va_list args;
va_start(args, required);
int opt1 = va_arg(args, int);  // Optional
int opt2 = va_arg(args, int);  // Optional
va_end(args);
// Use defaults if not provided
if (opt1 == 0) opt1 = 10;  // Default
if (opt2 == 0) opt2 = 20;  // Default
return required + opt1 + opt2;
}
int main() {
printf("=== Best Practices ===\n\n");
printf("sum_ints(5, 1,2,3,4,5) = %d\n", 
sum_ints(5, 1, 2, 3, 4, 5));
printf("sum_ints_sentinel(1,2,3,4,5,0) = %d\n",
sum_ints_sentinel(1, 2, 3, 4, 5, 0));
printf("bounded_sum(3, 10,20,30) = %d\n",
bounded_sum(3, 10, 20, 30));
printf("flexible_function(5) = %d\n", 
flexible_function(5));
printf("flexible_function(5, 100, 200) = %d\n", 
flexible_function(5, 100, 200));
return 0;
}

Summary Table

Conclusion

Variadic functions are a powerful feature in C that enable flexible, expressive interfaces. Key takeaways:

1. Always include a count or format string to know how many arguments to expect
2. Use va_list versions of functions for better composability
3. Be aware of default argument promotions (char→int, float→double)
4. Always pair va_start with va_end to prevent resource leaks
5. Use va_copy when you need to traverse arguments multiple times
6. Document argument expectations clearly in function comments
7. Consider type safety by using _Generic macros where possible

Common use cases:

• Logging and debugging systems
• Mathematical functions (sum, average, min, max)
• String formatting and concatenation
• Wrapper functions for standard I/O
• Configuration and initialization functions

Mastering variadic functions allows C programmers to create elegant, flexible APIs that adapt to varying requirements while maintaining the performance and control that C provides.