Passando un numero variabile di argomenti

Supponiamo che io abbia una funzione C che accetta un numero variabile di argomenti: come posso chiamare un'altra funzione che prevede un numero variabile di argomenti dall'interno di essa, passando tutti gli argomenti che sono entrati nella prima funzione?

Esempio:

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

Per passare le ellissi, devi convertirle in una va_list e usare quella va_list nella tua seconda funzione. specificamente;

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

Non c'è modo di chiamare (ad es.) Printf senza sapere quanti argomenti stai passando ad esso, a meno che tu non voglia fare brutti scherzi e non portatili.

La soluzione generalmente usata è quella di fornire sempre una forma alternativa di funzioni vararg, quindi printfha una vprintfche prende il va_listposto di .... Le ...versioni sono solo involucri attorno alle va_listversioni.

Le funzioni variabili possono essere pericolose . Ecco un trucco più sicuro:

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

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

Nel magnifico C ++ 0x potresti usare modelli variadic:

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

È possibile utilizzare l'assemblaggio in linea per la chiamata di funzione. (in questo codice presumo che gli argomenti siano caratteri).

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

Puoi anche provare la macro.

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

Anche se puoi risolvere il passaggio del formatter memorizzandolo prima nel buffer locale, ma questo ha bisogno di stack e a volte può essere un problema da affrontare. Ho provato a seguire e sembra funzionare bene.

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

Spero che questo ti aiuti.

La soluzione di Ross ha ripulito un po '. Funziona solo se tutti gli arg sono puntatori. Anche l'implementazione del linguaggio deve supportare l'eliminazione della virgola precedente se __VA_ARGS__è vuota (sia Visual Studio C ++ che 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);}

Supponiamo che tu abbia una tipica funzione variadica che hai scritto. Poiché è necessario almeno un argomento prima di quello variadico ..., è necessario scrivere sempre un argomento aggiuntivo durante l'utilizzo.

O tu?

Se si avvolge la funzione variadica in una macro, non è necessario alcun argomento precedente. Considera questo esempio:

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

Questo è ovviamente molto più conveniente, poiché non è necessario specificare l'argomento iniziale ogni volta.

Non sono sicuro che funzioni per tutti i compilatori, ma per me ha funzionato finora.

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

Puoi aggiungere ... a inner_func () se vuoi, ma non ti serve. Funziona perché va_start utilizza l'indirizzo della variabile data come punto iniziale. In questo caso, gli stiamo fornendo un riferimento a una variabile in func (). Quindi usa quell'indirizzo e legge le variabili dopo quella nello stack. La funzione inner_func () sta leggendo l'indirizzo dello stack di func (). Quindi funziona solo se entrambe le funzioni usano lo stesso segmento di stack.

Le macro va_start e va_arg generalmente funzionano se si fornisce loro var come punto di partenza. Quindi, se vuoi, puoi passare i puntatori ad altre funzioni e usare anche quelle. Puoi creare le tue macro abbastanza facilmente. Tutto ciò che fanno le macro è l'indirizzo di memoria del typecast. Tuttavia, farli funzionare per tutti i compilatori e le convenzioni di chiamata è fastidioso. Quindi è generalmente più facile usare quelli forniti con il compilatore.