Передача переменного количества аргументов вокруг

Функции Variadic могут быть опасными. Здесь более безопасный трюк:

   void func(type* values) {
        while(*values) {
            x = *values++;
            /* do whatever with x */
        }
    }

func((type[]){val1,val2,val3,val4,0});

Нет способа вызвать (например) printf, не зная, сколько аргументов вы переходите к нему, если вы не хотите попасть в непослушные и непереносимые трюки.

Обычно используемое решение состоит в том, чтобы всегда предоставлять альтернативную форму функций vararg, поэтому printf имеет vprintf, который вместо ... принимает va_list. Версия ... - это всего лишь обертки вокруг версий va_list.

В великолепном С++ 0x вы можете использовать вариативные шаблоны:

template <typename ... Ts>
void format_string(char *fmt, Ts ... ts) {}

template <typename ... Ts>
void debug_print(int dbg_lvl, char *fmt, Ts ... ts)
{
  format_string(fmt, ts...);
}

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

void format_string(char *fmt, ...);
void debug_print(int dbg_level, int numOfArgs, char *fmt, ...)
    {
        va_list argumentsToPass;
        va_start(argumentsToPass, fmt);
        char *list = new char[numOfArgs];
        for(int n = 0; n < numOfArgs; n++)
            list[n] = va_arg(argumentsToPass, char);
        va_end(argumentsToPass);
        for(int n = numOfArgs - 1; n >= 0; n--)
        {
            char next;
            next = list[n];
            __asm push next;
        }
        __asm push fmt;
        __asm call format_string;
        fprintf(stdout, fmt);
    }

Вы также можете попробовать макрос.

#define NONE    0x00
#define DBG     0x1F
#define INFO    0x0F
#define ERR     0x07
#define EMR     0x03
#define CRIT    0x01

#define DEBUG_LEVEL ERR

#define WHERESTR "[FILE : %s, FUNC : %s, LINE : %d]: "
#define WHEREARG __FILE__,__func__,__LINE__
#define DEBUG(...)  fprintf(stderr, __VA_ARGS__)
#define DEBUG_PRINT(X, _fmt, ...)  if((DEBUG_LEVEL & X) == X) \
                                      DEBUG(WHERESTR _fmt, WHEREARG,__VA_ARGS__)

int main()
{
    int x=10;
    DEBUG_PRINT(DBG, "i am x %d\n", x);
    return 0;
}

Решение Росса немного очистилось. Работает только в том случае, если все аргументы являются указателями. Кроме того, реализация языка должна поддерживать возврат предыдущей запятой, если __VA_ARGS__ пуст (как Visual Studio С++, так и GCC).

// pass number of arguments version
 #define callVardicMethodSafely(...) {value_t *args[] = {NULL, __VA_ARGS__}; _actualFunction(args+1,sizeof(args) / sizeof(*args) - 1);}


// NULL terminated array version
 #define callVardicMethodSafely(...) {value_t *args[] = {NULL, __VA_ARGS__, NULL}; _actualFunction(args+1);}

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

Или вы?

Если вы переносите свою вариационную функцию в макрос, вам не нужен предшествующий arg. Рассмотрим этот пример:

#define LOGI(...)
    ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))

Это, безусловно, гораздо удобнее, так как вам не нужно указывать начальный аргумент каждый раз.

Я не уверен, что это работает для всех компиляторов, но он до сих пор работал у меня.

void inner_func(int &i)
{
  va_list vars;
  va_start(vars, i);
  int j = va_arg(vars);
  va_end(vars); // Generally useless, but should be included.
}

void func(int i, ...)
{
  inner_func(i);
}

Вы можете добавить... в inner_func(), если хотите, но вам это не нужно. Он работает, потому что va_start использует адрес данной переменной в качестве начальной точки. В этом случае мы даем ссылку на переменную в func(). Поэтому он использует этот адрес и считывает переменные после этого в стеке. Функция inner_func() считывает из адреса стека func(). Таким образом, он работает только в том случае, если обе функции используют один и тот же сегмент стека.

Макросы va_start и va_arg обычно будут работать, если вы дадите им любой var в качестве отправной точки. Поэтому, если вы хотите, вы можете передавать указатели на другие функции и использовать их тоже. Вы можете сделать свои собственные макросы достаточно легко. Все макросы - это адреса памяти типов. Однако заставить их работать для всех компиляторов и вызывающих конвенций раздражает. Поэтому, как правило, проще использовать те, которые поставляются вместе с компилятором.