Przekazywanie zmiennej liczby argumentów

Powiedzmy, że mam funkcję C, która pobiera zmienną liczbę argumentów: Jak mogę wywołać inną funkcję, która oczekuje od niej zmiennej liczby argumentów, przekazując wszystkie argumenty, które dostały się do pierwszej funkcji?

Przykład:

void format_string(char *fmt, ...);

void debug_print(int dbg_lvl, char *fmt, ...) {
    format_string(fmt, /* how do I pass all the arguments from '...'? */);
    fprintf(stdout, fmt);
 }

Aby przekazać elipsy, musisz przekonwertować je na listę va_list i użyć tej listy va w swojej drugiej funkcji. Konkretnie;

void format_string(char *fmt,va_list argptr, char *formatted_string);


void debug_print(int dbg_lvl, char *fmt, ...) 
{    
 char formatted_string[MAX_FMT_SIZE];

 va_list argptr;
 va_start(argptr,fmt);
 format_string(fmt, argptr, formatted_string);
 va_end(argptr);
 fprintf(stdout, "%s",formatted_string);
}

Nie ma możliwości wywołania (np.) Printf bez wiedzy, ile argumentów mu przekazujesz, chyba że chcesz dostać się do niegrzecznych i nieprzenośnych sztuczek.

Powszechnie stosowanym rozwiązaniem jest, aby zawsze zapewnić alternatywną postać funkcji vararg, więc printfma vprintfco zajmuje va_listw miejsce .... The... wersje są tylko obwolut wokół va_listwersjach.

Funkcje Variadic mogą być niebezpieczne . Oto bezpieczniejsza sztuczka:

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

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

We wspaniałym C ++ 0x możesz użyć różnych szablonów:

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...);
}

Można użyć złożenia wbudowanego do wywołania funkcji. (w tym kodzie zakładam, że argumentami są znaki).

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);
    }

Możesz także spróbować makra.

#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;
}

Chociaż można rozwiązać przekazanie formatera, najpierw przechowując go w buforze lokalnym, ale wymaga to stosu i może czasem być problem. Próbowałem śledzić i wydaje się, że działa dobrze.

#include <stdarg.h>
#include <stdio.h>

void print(char const* fmt, ...)
{
    va_list arg;
    va_start(arg, fmt);
    vprintf(fmt, arg);
    va_end(arg);
}

void printFormatted(char const* fmt, va_list arg)
{
    vprintf(fmt, arg);
}

void showLog(int mdl, char const* type, ...)
{
    print("\nMDL: %d, TYPE: %s", mdl, type);

    va_list arg;
    va_start(arg, type);
    char const* fmt = va_arg(arg, char const*);
    printFormatted(fmt, arg);
    va_end(arg);
}

int main() 
{
    int x = 3, y = 6;
    showLog(1, "INF, ", "Value = %d, %d Looks Good! %s", x, y, "Infact Awesome!!");
    showLog(1, "ERR");
}

Mam nadzieję że to pomoże.

Rozwiązanie Rossa zostało trochę oczyszczone. Działa tylko wtedy, gdy wszystkie argumenty są wskaźnikami. Również implementacja języka musi obsługiwać wyświetlanie poprzedniego przecinka, jeśli __VA_ARGS__jest pusty (zarówno Visual Studio C ++, jak i GCC do).

// 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);}

Załóżmy, że masz typową funkcję wariadyczną, którą napisałeś. Ponieważ przed argumentem variadycznym wymagany jest co najmniej jeden argument ..., zawsze musisz napisać dodatkowy argument w użyciu.

Czy ty

Jeśli zawijasz funkcję variadic w makrze, nie potrzebujesz poprzedzającego argumentu. Rozważ ten przykład:

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

Jest to oczywiście znacznie wygodniejsze, ponieważ nie trzeba za każdym razem określać początkowego argumentu.

Nie jestem pewien, czy to działa dla wszystkich kompilatorów, ale do tej pory działało dla mnie.

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);
}

Możesz dodać ... do inner_func (), jeśli chcesz, ale nie potrzebujesz. Działa, ponieważ va_start używa adresu danej zmiennej jako punktu początkowego. W tym przypadku podajemy mu odwołanie do zmiennej w func (). Używa więc tego adresu i odczytuje zmienne później na stosie. Funkcja inner_func () odczytuje z adresu stosu func (). Działa to tylko wtedy, gdy obie funkcje używają tego samego segmentu stosu.

Makra va_start i va_arg będą na ogół działać, jeśli podasz im dowolny var jako punkt początkowy. Więc jeśli chcesz, możesz przekazać wskaźniki do innych funkcji i również z nich korzystać. Możesz łatwo tworzyć własne makra. Wszystkie makra to adresy pamięci typecast. Jednak zmuszanie ich do działania dla wszystkich kompilatorów i konwencji wywoływania jest denerwujące. Ogólnie łatwiej jest korzystać z tych, które są dostarczane z kompilatorem.