Passando un numero variabile di argomenti

Question

Supponi di avere una funzione C che accetta un numero variabile di argomenti: come posso chiamare un'altra funzione che prevede un numero variabile di argomenti al suo interno, 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);
 }

Answer 1

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

Answer 2

Non c'è modo di chiamare (ad es.) printf senza sapere quanti argomenti stai passando ad esso, a meno che tu non voglia entrare in trucchi cattivi e non portatili.

La soluzione generalmente usata è fornire sempre una forma alternativa di funzioni vararg, quindi printf ha vprintf che prende un va_list al posto di il ... . Le versioni ... sono solo involucri attorno alle versioni va_list .

Answer 3

Funzioni variabili può essere pericoloso . Ecco un trucco più sicuro:

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

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

Answer 4

Nel magnifico C ++ 0x puoi 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...);
}

Answer 5

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

Answer 6

Puoi anche provare 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;
}

Answer 7

Sebbene tu possa 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 aiuti.

Answer 8

La soluzione di Ross è stata ripulita 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__ è vuoto (sia Visual Studio C ++ che GCC lo fanno).

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

Answer 9

Supponiamo che tu abbia una tipica funzione variadica che hai scritto. Poiché è necessario almeno un argomento prima di quello variabile ... , devi sempre scrivere un argomento in più in uso.

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.

Answer 10

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

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 funzionano generalmente se si dà loro una 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.