C Variadic Function

​

Syntax

// Pre-C23 (and C23) syntax requiring at least one fixed parameter
return_type function_name(data_type fixed_parameter, ...);

// C23 syntax allowing zero fixed parameters
return_type function_name(...);

​

The <stdarg.h> Interface

• va_list: An opaque state type used to iterate through the variable arguments. Depending on the Application Binary Interface (ABI), this may be a simple pointer or a complex structure managing both hardware register save areas and stack overflow areas (as is common in modern ABIs like x86_64 System V and ARM64).
• va_start: Initializes the va_list instance.
  • Pre-C23: va_start(va_list ap, last_fixed_arg) requires the name of the last known fixed parameter to initialize the state.
  • C23: va_start(va_list ap, ...) allows initialization with a single argument (ap), accommodating functions with zero named parameters. To maintain backwards compatibility with pre-C23 code, it still accepts a second argument (the last named parameter). Any additional arguments passed to va_start in C23 are evaluated and discarded.
• va_arg(va_list ap, type): Retrieves the current argument and advances the va_list state to the next argument. The type parameter dictates the byte size and memory alignment to read from the underlying registers or stack.
• va_end(va_list ap): Cleans up the va_list object. It must be called before the function returns to avoid undefined behavior.
• va_copy(va_list dest, va_list src): Safely duplicates the state of a va_list, allowing multiple traversals of the argument list.

​

Implementation Lifecycle

#include <stdarg.h>

// Pre-C23 compatible implementation
void process_arguments(int count, ...) {
    va_list args;
    
    // 1. Initialize the argument list state
    va_start(args, count); // C23 allows omitting 'count': va_start(args);
    
    for (int i = 0; i < count; i++) {
        // 2. Extract the next argument by specifying its expected type
        int current_value = va_arg(args, int);
        
        // (Internal processing logic omitted)
    }
    
    // 3. Clean up the argument list
    va_end(args);
}

​

Technical Constraints and Memory Mechanics

• Integer types smaller than int (e.g., char, short) are promoted to int (or unsigned int).
• float is promoted to double.

1. A fixed parameter specifying the exact count.
2. A format string containing type specifiers.
3. A sentinel value (e.g., NULL or -1) terminating the argument list.

• Invoking va_arg more times than the number of arguments actually passed.
• Providing a type to va_arg that does not strictly match the promoted type of the passed argument.
• Failing to invoke va_end before the function returns.
• Attempting to extract an aggregate type like an array directly. Arrays decay to pointers when passed as arguments to a function, so they must be extracted as their decayed pointer type (e.g., va_arg(args, int*)).