Что про эллипсис и va_list сказано в Стандарте

• Можно объявить функцию, принимающую произвольное число аргументов. Т.е. аргументов у функции может быть больше, чем параметров. Для этого список ее параметров должен заканчиваться эллипсисом, но так же должен присутствовать хотя бы один фиксированный параметр [C11 6.9.1/8]:
  
  

  void foo(int parm1, int parm2, ...);

• В саму функцию не передается информация о количестве и типах аргументов, соответствующих эллипсису. Т.е. после последнего именованного параметра (parm2 в примере выше) [C11 6.7.6.3/9].
  
• Для доступа к этим аргументам надо использовать объявленные в заголовке <stdarg.h> тип va_list и 4 (3 до стандарта C11) макроса: va_start, va_arg, va_end и va_copy (начиная с C11) [C11 7.16].
  
  
  Например

  int add(int count, ...) 
  {
      int result = 0;
      va_list args;
      va_start(args, count);
      for (int i = 0; i < count; ++i)
      {
          result += va_arg(args, int);
      }
      va_end(args);
      return result;
  }

  
  Да, функция не знает, сколько у нее аргументов. Ей надо как-то передать это число. В данном случае — через единственный именованный аргумент (другой распространенный вариант — передавать последним аргументом NULL, как в execl, или 0).
• Последний именованный аргумент не может иметь класс хранения register, не может быть функцией или массивом. Иначе — неопределенное поведение [C11 7.16.1.4/4].
• Причем к последнему именованному аргументу и всем безымянным применяется «повышение типа аргумента по умолчанию» (default argument promotion; если есть хороший перевод этого понятия на русский, я с радостью его использую). Это значит, что если у аргумента тип char, short (со знаком или без) или float, то к соответствующим параметрам надо обращаться как к int, int (со знаком или без) или double. Иначе — неопределенное поведение [C11 7.16.1.1/2].
• Про тип va_list сказано только то, что он объявлен в <stdarg.h> и является полным (т.е. размер объекта этого типа известен) [C11 7.16/3].

Почему? А потому что!

Кстати, не существует приемлемого способа написать переносимую функцию от произвольного числа аргументов, т.к. нет переносимого способа для вызванной функции узнать, сколько же аргументов ей передано при вызове. … printf, наиболее типичная функция языка C от произвольного числа аргументов, … не является переносимой и должна быть реализована для каждой системы.

#ifndef _STADARG
#define _STADARG

#define _AUPBND 1
#define _ADNBND 1

typedef char* va_list

#define va_arg(ap, T)  (*(T*)(((ap) += _Bnd(T, _AUPBND)) - _Bnd(T, _ADNBND)))

#define va_end(ap)  (void)0

#define va_start(ap, A)  (void)((ap) = (char*)&(A) + _Bnd(A, _AUPBND))

#define _Bnd(X, bnd)  (sizeof(X)  + (bnd) & ~(bnd))

#endif

typedef struct
{
    unsigned int gp_offset;
    unsigned int fp_offset;
    void *overflow_arg_area;
    void *reg_save_area;
} va_list[1];

Вариативные функции в C++

• Т.к. C++ в отличие от С позволяет получать адрес register переменных, то последний именованный аргумент вариативной функции может иметь этот класс хранения.
  
• Т.к. появившиеся в C++ ссылки нарушают негласное правило вариативных функций С — размер параметра должен совпадать с размером его объявленного типа — то последний именованный аргумент не может быть ссылкой. Иначе — неопределенное поведение.
  
• Т.к. в C++ нет понятия «повышения типа аргумента по умолчанию», то фразу
  

  If the parameter parmN is declared with… a type that is not compatible with the type that results after application of the default argument promotions, the behavior is undefined

  надо заменить на

  If the parameter parmN is declared with… a type that is not compatible with the type that results when passing an argument for which there is no parameter, the behavior is undefined

Как легко и неправильно использовать вариативные функции

1. Неправильно объявлять последний именованный аргумент с повышаемым типом, т.е. char, signed char, unsigned char, singed short, unsigned short или float. Результатом согласно Стандарту будет неопределенное поведение.
   
   
   Неправильный код

   void foo(float n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << va_arg(va, int) << std::endl;
       va_end(va);
   }

   
   
   
   Из всех компиляторов, которые были у меня под рукой (gcc, clang, MSVC), только clang выдал предупреждение.
   
   
   Предупреждение от clang

   ./test.cpp:7:18: warning: passing an object that undergoes default argument promotion to 'va_start' has undefined behavior [-Wvarargs]
       va_start(va, n);
                    ^

   
   И хотя во всех случаях скомпилированный код вел себя корректно, рассчитывать на это не стоит.
   
   
   Правильно будет так

   void foo(double n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << va_arg(va, int) << std::endl;
       va_end(va);
   }

   
   
2. Неправильно объявлять последний именованный аргумент ссылкой. Любой ссылкой. Стандарт и в этом случае обещает неопределенное поведение.
   
   
   Неправильный код

   void foo(int& n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << va_arg(va, int) << std::endl;
       va_end(va);
   }

   
   gcc 7.3.0 скомпилировал этот код без единого замечания. сlang 6.0.0 выдал предупреждение, но все-таки компиляцию выполнил.
   
   
   Предупреждение от clang

   ./test.cpp:7:18: warning: passing an object of reference type to 'va_start' has undefined behavior [-Wvarargs]
       va_start(va, n);
                    ^

   
   В обоих случаях программа отработала корректно (повезло, нельзя на это полагаться). А вот MSVC 19.15.26730 отличился — он отказался компилировать код, т.к. аргумент va_start не должен быть ссылкой.
   
   
   Ошибка от MSVC

   c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.15.26726\include\vadefs.h(151): error C2338: va_start argument must not have reference type and must not be parenthesized

   
   
   Ну а правильный вариант выглядит, например, так

   void foo(int* n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << va_arg(va, int) << std::endl;
       va_end(va);
   }

   
   
3. Неправильно запрашивать у va_arg повышаемый тип — char, short или float.
   
   
   Неправильный код

   #include <cstdarg>
   #include <iostream>
   
   void foo(int n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << va_arg(va, int) << std::endl;
       std::cout << va_arg(va, float) << std::endl;
       std::cout << va_arg(va, int) << std::endl;
       va_end(va);
   }
   
   int main()
   {
       foo(0, 1, 2.0f, 3);
       return 0;
   }

   
   Здесь интереснее. gcc при компиляции выдает предупреждение, что надо использовать double вместо float, а если этот код все-таки будет выполнен, то программа завершится с ошибкой.
   
   
   Предупреждение от gcc

   ./test.cpp:9:15: warning: ‘float’ is promoted to ‘double’ when passed through ‘...’
     std::cout << va_arg(va, float) << std::endl;
                  ^~~~~~
   ./test.cpp:9:15: note: (so you should pass ‘double’ not ‘float’ to ‘va_arg’)
   ./test.cpp:9:15: note: if this code is reached, the program will abort

   
   И действительно, программа аварийно завершается с жалобой на недопустимую инструкцию.
   Анализ дампа показывает, что программа получила сигнал SIGILL. И еще показывает структуру va_list. Для 32-х бит это
   
   

   va = 0xfffc6918 ""

   
   т.е. va_list — просто char*. Для 64-х бит:
   
   

   va = {{gp_offset = 16, fp_offset = 48, overflow_arg_area = 0x7ffef147e7e0, reg_save_area = 0x7ffef147e720}}

   
   т.е. ровно то, что описано в SystemV ABI AMD64.
   
   clang при компиляции предупреждает о неопределенном поведении и тоже предлагает заменить float на double.
   
   
   Предупреждение от clang

   ./test.cpp:9:26: warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' [-Wvarargs]
           std::cout << va_arg(va, float) << std::endl;
                                   ^~~~~

   
   Но программа уже не падает, 32-х разрядная версия выдает:
   
   

   1
   0
   1073741824

   
   64-х разрядная:
   
   

   1
   0
   3

   
   MSVC выдает точно такие же результаты, только без предупреждений, даже с /Wall.
   
   Тут можно было бы предположить, что разница между 32 и 64 битами обусловлена тем, что в первом случае ABI передает вызванной функции все аргументы через стек, а во втором первые четыре (Windows) или шесть (Linux) аргументов через регистры процессора, остальные — через стек [wiki]. Но нет, если вызывать foo не с 4 аргументами, а с 19, и так же выводить их, то результат будет прежний: полное месиво в 32-х разрядном варианте, и нули для всех float в 64-х разрядном. Т.е. дело-то конечно в ABI, но не в использовании регистров для передачи аргументов.
   
   
   Ну а правильно, конечно, делать так

   void foo(int n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << va_arg(va, int) << std::endl;
       std::cout << va_arg(va, double) << std::endl;
       std::cout << va_arg(va, int) << std::endl;
       va_end(va);
   }

   
   
4. Неправильно передавать в качестве безымянного аргумента экземпляр класса с нетривиальным конструктором или деструктором. Если, конечно, судьба этого кода волнует вас хоть немного больше, чем «скомпилировать и запустить здесь и сейчас».
   
   
   Неправильный код

   #include <cstdarg>
   #include <iostream>
   
   struct Bar
   {
       Bar() { std::cout << "Bar default ctor" << std::endl; }
       Bar(const Bar&) { std::cout << "Bar copy ctor" << std::endl; }
       ~Bar() { std::cout << "Bar dtor" << std::endl; }
   };
   
   struct Cafe
   {
       Cafe() { std::cout << "Cafe default ctor" << std::endl; }
       Cafe(const Cafe&) { std::cout << "Cafe copy ctor" << std::endl; }
       ~Cafe() { std::cout << "Cafe dtor" << std::endl; }
   };
   
   void foo(int n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << "Before va_arg" << std::endl;
       const auto b = va_arg(va, Bar);
       va_end(va);
   }
   
   int main()
   {
       Bar b;
       Cafe c;
       foo(1, b, c);
       return 0;
   }

   
   Строже всех опять clang. Он просто отказывается компилировать этот код из-за того, что второй аргумент va_arg не является POD типом, и предупреждает, что при запуске программа упадет.
   
   
   Предупреждение от clang

   ./test.cpp:23:31: error: second argument to 'va_arg' is of non-POD type 'Bar' [-Wnon-pod-varargs]
       const auto b = va_arg(va, Bar);
                                 ^~~
   ./test.cpp:31:12: error: cannot pass object of non-trivial type 'Bar' through variadic function; call will abort at runtime [-Wnon-pod-varargs]
       foo(1, b, c);
              ^

   
   Так и будет, если все-таки выполнить компиляцию с флагом -Wno-non-pod-varargs.
   
   MSVC предупреждает, что использование в данном случае типов с нетривиальным конструкторов непереносимо.
   
   
   Предупреждение от MSVC

   d:\my documents\visual studio 2017\projects\test\test\main.cpp(31): warning C4840: непереносимое использование класса "Bar" в качестве аргумента в функции с переменным числом аргументов

   
   Но код компилируется и выполняется корректно. В консоли получается следующее:
   
   
   Результат запуска

   Bar default ctor
   Cafe default ctor
   Before va_arg
   Bar copy ctor
   Bar dtor
   Cafe dtor
   Bar dtor

   
   Т.е. копия создается только в момент вызова va_arg, а аргумент, получается, передается по ссылке. Как-то не очевидно, но Стандарт разрешает.
   
   gcc 6.3.0 компилирует без единого замечания. На выходе имеем то же самое:
   
   
   Результат запуска

   Bar default ctor
   Cafe default ctor
   Before va_arg
   Bar copy ctor
   Bar dtor
   Cafe dtor
   Bar dtor

   
   gcc 7.3.0 тоже ни о чем не предупреждает, но вот поведение меняется:
   
   
   Результат запуска

   Bar default ctor
   Cafe default ctor
   Cafe copy ctor
   Bar copy ctor
   Before va_arg
   Bar copy ctor
   Bar dtor
   Bar dtor
   Cafe dtor
   Cafe dtor
   Bar dtor

   
   Т.е. эта версия компилятора передает аргументы по значению, а при вызове va_arg делает еще одну копию. Весело было бы искать эту разницу при переходе с 6-ой на 7-ую версию gcc, если у конструкторов/деструкторов есть побочные эффекты.
   
   Кстати, если явно передавать и запрашивать ссылку на класс:
   
   
   Еще один неправильный код

   void foo(int n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << "Before va_arg" << std::endl;
       const auto& b = va_arg(va, Bar&);
       va_end(va);
   }
   
   int main()
   {
       Bar b;
       Cafe c;
       foo(1, std::ref(b), c);
       return 0;
   }

   
   то все компиляторы выдадут ошибку. Как того и требует Стандарт.
   
   В общем, если уж сильно хочется, передавать аргументы лучше по указателю.
   
   
   Вот так

   void foo(int n, ...)
   {
       va_list va;
       va_start(va, n);
       std::cout << "Before va_arg" << std::endl;
       const auto* b = va_arg(va, Bar*);
       va_end(va);
   }
   
   int main()
   {
       Bar b;
       Cafe c;
       foo(1, &b, &c);
       return 0;
   }

   
   

Разрешение перегрузки и вариативные функции

#include <iostream>

void foo(...)
{
    std::cout << "C variadic function" << std::endl;
}

void foo(int)
{
    std::cout << "Ordinary function" << std::endl;
}

int main()
{
    foo(1);
    foo(1ul);
    foo();

    return 0;
}

$ ./test 
Ordinary function
Ordinary function
C variadic function

#include <iostream>

void foo(...)
{
    std::cout << "C variadic function" << std::endl;
}

void foo()
{
    std::cout << "Ordinary function without arguments" << std::endl;
}

int main()
{
    foo(1);
    foo();

    return 0;
}

./test.cpp:16:9: error: call of overloaded ‘foo()’ is ambiguous
     foo();
         ^
./test.cpp:3:6: note: candidate: void foo(...)
 void foo(...)
      ^~~
./test.cpp:8:6: note: candidate: void foo()
 void foo()
      ^~~

Когда же все-таки стоит использовать вариативные функции

• Самый частый и очевидный случай — обратная совместимость. Сюда я отнесу как использование сторонних C библиотек (мой случай с JNI), так и предоставление C API к C++ реализации.
  
• SFINAE. Тут очень кстати и то, что в C++ вариативная функция не обязана иметь именованных аргументов, и то, что при разрешении перегруженных функций вариативная функция рассматривается в последнюю очередь (при наличии хотя бы одного аргумента). И как любую другую функцию вариативную функцию можно только объявить, но никогда не вызывать.
  
  
  Пример

  template <class T> 
  struct HasFoo
  {
  private:
      template <class U, class = decltype(std::declval<U>().foo())>
      static void detect(const U&);
  
      static int detect(...);
  
  public:
      static constexpr bool value = std::is_same<void, decltype(detect(std::declval<T>()))>::value;
  };

  
  Хотя в C++14 можно сделать немного по-другому.
  
  
  Другой пример

  template <class T> 
  struct HasFoo
  {
  private:
      template <class U, class = decltype(std::declval<U>().foo())>
      static constexpr bool detect(const U*)
      {
          return true;
      }
  
      template <class U>
      static constexpr bool detect(...)
      {
          return false;
      }
  
  public:
      static constexpr bool value = detect<T>(nullptr);
  };

  
  И в этом случае уже надо следить, с какими аргументами может быть вызвана detect(...). Я бы предпочел изменить пару строчек и использовать современную альтернативу вариативным функциям, лишенную всех их недостатков.
  

Вариативные шаблоны или как правильно создавать функции от произвольного числа аргументов в современном C++

• пакет параметров шаблона (template parameter pack) — это такой параметр шаблона, вместо которого можно передать любое (включая 0) количество аргументов шаблона;
  
• пакет параметров функции (function parameter pack) — соответственно, это параметр функции, принимающий любое (в т.ч. 0) количество аргументов функции;
  
• и раскрытие пакета (pack expansion) — это единственное, что можно сделать с пакетом параметров.
  

template <class ... Args>
void foo(const std::string& format, Args ... args)
{
    printf(format.c_str(), args...);
}

• пакет параметров функции можно раскрыть в список аргументов другой функции

  template <class ... Args>
  void bar(const std::string& format, Args ... args)
  {
      foo<Args...>(format.c_str(), args...);
  }

  
  
• или в список инициализации

  template <class ... Args>
  void foo(const std::string& format, Args ... args)
  {
      const auto list = {args...};
  }

  
  
• или в список захвата лямбды

  template <class ... Args>
  void foo(const std::string& format, Args ... args)
  {
      auto lambda = [&format, args...] ()
      {
          printf(format.c_str(), args...);
      };
      lambda();
  }

  
  
• еще пакет параметров функции можно раскрыть в выражении свертки

  template <class ... Args>
  int foo(Args ... args)
  {
      return (0 + ... + args);
  }

  
  Свертки появились в С++14 и могут быть унарными и бинарными, правыми и левыми. Самое полное описание, как всегда, в Стандарте [C++17 8.1.6].
  
• оба типа пакета параметров можно раскрывать в оператор sizeof...

  template <class ... Args>
  void foo(Args ... args)
  {
      const auto size1 = sizeof...(Args);
      const auto size2 = sizeof...(args);
  }

  
  

template <class ... Args>
void foo()
{
    using OneTuple = std::tuple<std::tuple<Args>...>;
    using NestTuple = std::tuple<std::tuple<Args...>>;
}

Пример реализации printf с помощью вариативных шаблонов

void printf(const char* s)
{
    while (*s)
    {
        if (*s == '%' && *++s != '%')
            throw std::runtime_error("invalid format string: missing arguments");
        std::cout << *s++;
    }
}

template <typename T, typename ... Args>
void printf(const char* s, T value, Args ... args)
{
    while (*s)
    {
        if (*s == '%' && *++s != '%')
        {
            std::cout << value;
            return printf(++s, args...);
        }
        std::cout << *s++;
    }
    throw std::runtime_error("extra arguments provided to printf");
}

template <typename ... Args>
void printf(const std::string& fmt, const Args& ... args)
{
    size_t fmtIndex = 0;
    size_t placeHolders = 0;
    auto printFmt = [&fmt, &fmtIndex, &placeHolders]()
    {
        for (; fmtIndex < fmt.size(); ++fmtIndex)
        {
            if (fmt[fmtIndex] != '%')
                std::cout << fmt[fmtIndex];
            else if (++fmtIndex < fmt.size())
            {
                if (fmt[fmtIndex] == '%')
                    std::cout << '%';
                else
                {
                    ++fmtIndex;
                    ++placeHolders;
                    break;
                }
            }
        }
    };

    ((printFmt(), std::cout << args), ..., (printFmt()));

    if (placeHolders < sizeof...(args))
        throw std::runtime_error("extra arguments provided to printf");
    if (placeHolders > sizeof...(args))
        throw std::runtime_error("invalid format string: missing arguments");
}

Разрешение перегрузки и вариативные шаблонные функции

#include <iostream>

void foo(int)
{
    std::cout << "Ordinary function" << std::endl;
}

void foo()
{
    std::cout << "Ordinary function without arguments" << std::endl;
}

template <class T>
void foo(T)
{
    std::cout << "Template function" << std::endl;
}

template <class ... Args>
void foo(Args ...)
{
    std::cout << "Template variadic function" << std::endl;
}

int main()
{
    foo(1);
    foo();
    foo(2.0);
    foo(1, 2);

    return 0;
}

$ ./test 
Ordinary function
Ordinary function without arguments
Template function
Template variadic function

#include <iostream>

void foo(...)
{
    std::cout << "C variadic function" << std::endl;
}

template <class ... Args>
void foo(Args ...)
{
    std::cout << "Template variadic function" << std::endl;
}

int main()
{
    foo(1);
    foo();

    return 0;
}

$ ./test 
Template variadic function
C variadic function

Небольшое замечание о скорости вариативных шаблонных функций

Краткое резюме и вывод

• Не знают ни числа своих аргументов, ни их типов. Разработчик должен использовать часть аргументов функции для того, чтобы передать информацию об остальных.
  
• Неявно повышают типы неименованных аргументов (и последнего именованного). Если забыть об этом, получится неопределенное поведение.
  
• Сохраняют обратную совместимость с чистым C и потому не поддерживают передачу аргументов по ссылке.
  
• До C++11 не поддерживали аргументы не POD типов, а начиная с C++11 поддержка нетривиальных типов оставлена на усмотрение компилятора. Т.е. поведение кода зависит от компилятора и его версии.
  

• Знают количество и типы всех своих аргументов.
  
• Типобезопасны, не меняют типы своих аргументов.
  
• Поддерживают передачу аргументов в любом виде — по значению, по указателю, по ссылке, по универсальной ссылке.
  
• Как и любые другие C++ функции, не имеют ограничений на типы аргументов.
  
• При разрешении перегрузки рассматриваются в последнюю очередь (уступая только вариативным C функциям), как наименее специализированные.
  

Литература и источники

• P.J. Plauger, The Standard C Library
  
• Brian W. Kernighan and Dennis M. Ritchie, The C Programming Language, 1st Edition
  
• Brian W. Kernighan and Dennis M. Ritchie, The C Programming Language, 2nd Edition
  
• Стандарт C11, черновик N1570
  
• Стандарт C++98
  
• Стандарт C++03
  
• Стандарт C++11, черновик N3337
  
• Стандарт C++14, черновик N4296
  
• Стандарт C++17, черновик N4659
  

P. S.