• "Normal" Functions:
  • Have a fixed and known number of formal parameters
  • The type of each parameter is known
• Variadic Functions:
  • Have one or more typed formal parameters
  • Have an unknown number of untyped formal parameters

• Functions with no formal parameters:
  • The number of actual parameters is unspecified and any number can be passed, but they will be ignored
• Functions with a void formal parameter:
  • There can be no actual parameters
• Variadic functions:
  • The number of actual parameters is variable and they can be used

• Declaration:
  • type name(type name, [type name,]... ...
  • Example: int max(int a, int b, ...)
• "Typical" Invocation:
  • Identical to "normal" functions but with a sentinel to indicate the last parameter
  • Example: max(10, 5, 13, 7, 9, -1)
• "Clever" Invocation:
  • Use one of the parameters (often a char array) to provide information about the number of other parameters
  • Example: printf("%d %d %d %d %d", 10, 5, 13, 7, 9)

• The Header File:
  • <stdarg.h>
• The Macros:
  • va_list: Data type
  • void va_start(va_list ap, type last_fixed): Initialize the argument pointer
  • type va_arg(va_list ap, type): Return the next argument (and update ap)
  • void va_end(va_list ap): Clean up
  • void va_copy(va_list destination, va_list source)

cexamples/variadic/extremes.c

        #include <stdarg.h>
#include "extremes.h"

// Find the maximum of 2 (or more) non-negative integers.
// (Note: Pass a negative value as the last parameter.)
int 
max(int a, int b, ...)
{
  int      current, result;
  va_list  last_fixed;

  // Handle the two required parameters
  result = -1;
  if (a > result) result = a;
  if (b > result) result = b;

  // Handle the variable number of parameters
  va_start(last_fixed, b);
  do 
  {
    current = va_arg(last_fixed, int);
    if (current > result) result = current;

  } while (current >= 0); // The sentinel hasn't been encountered
  va_end(last_fixed);

  return result;
}
        

• Use a Pointer to the Stack Frame:

  • typedef char *va_list;
    #define va_start(ap, v) (ap=(va_list) _ADDRESSOF(v) + _INTSIZEOF(v))
    #define va_arg(ap, t)   (*(t *)((ap += _INTSIZEOF(t)) - INTSIZEOF(t)))
    #define va_end(ap)      (ap = (va_list)0)
    

  • Note: Whether addresses increase or decrease depends on the way the stack is organized.
• Use an Array of Pointers:
  • Where the array is of length 1
• Use Registers:
  • va_start() then allocates memory and va_end() later frees memory