variable argument list

variable argument:

#define _ADDRESSOF(v)   ( &reinterpret_cast<const char &>(v) )

#elif   defined(_M_IX86)

//Interge promotions
#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

//v is a variable argument, and your argument list should at least have one variable argument, even if it is not used. If the placeholder argument is not supplied, there is no way to access the remaining argument.
#define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )

//return the argument of type t, and make ap point to the next argument's address.
#define _crt_va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

#define _crt_va_end(ap)      ( ap = (va_list)0 )

//test variable argument list
void _printf(const char* format, ...){
 va_list vl;
 va_start(vl, format);
 int nLen = strlen(format);
 for(int i = 0; i < nLen; i++){
  if(format[i] == '%'){
   switch(format[i+1]){
    case 'd':{cout<<va_arg(vl, int);}break;
    case 's':{cout<<va_arg(vl, const char*);}break;
    default:break;
   }
   i++;
  }
  else
   cout<<format[i];
 }
} 

Bellow doc are quoted from MSDN

Function declarations in which the last member of argument-declaration-list is the ellipsis (...) can take a variable number of arguments. In these cases, C++ provides type checking only for the explicitly declared arguments. You can use variable argument lists when you need to make a function so general that even the number and types of arguments can vary. The printf family of functions is an example of functions that use variable argument lists.

To access arguments after those declared, use the macros contained in the standard include file STDARG.H as described in Functions with Variable Argument Lists.

Microsoft Specific

Microsoft C++ allows the ellipsis to be specified as an argument if the ellipsis is the last argument and the ellipsis is preceded by a comma. Therefore, the declaration int Func( int i, ... ); is legal, but int Func( int i ... ); is not.

END Microsoft Specific

Declaration of a function that takes a variable number of arguments requires at least one placeholder argument, even if it is not used. If this placeholder argument is not supplied, there is no way to access the remaining arguments.

When arguments of type char are passed as variable arguments, they are converted to type int. Similarly, when arguments of type float are passed as variable arguments, they are converted to type double. Arguments of other types are subject to the usual integral and floating-point promotions. See Integral Promotions for more information.

Functions that require variable lists are declared using the ellipsis (...) in the argument list, as described in Variable Argument Lists. To access arguments passed to functions using this method, use the types and macros described in the STDARG.H standard include file in the CRT. For more information on these macros, see va_arg, va_end, va_start in the documentation for the C Run-Time Library.