Przekazywanie zmiennej liczby argumentów wokół

Question

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

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

Answer 1

zdać elipsy na temat, trzeba je konwertować do va_list i użyć tego va_list w 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); 
} 

Answer 2

Nie ma sposobu wywoływania (EG) printf, nie wiedząc, jak wiele argumentów jesteś przechodząc do niego, chyba że chcesz dostać się niegrzeczne i non-przenośnych sztuczek.

Powszechnie stosowanym rozwiązaniem jest, aby zawsze zapewnić alternatywną postać funkcji vararg tak printf ma vprintf która przyjmuje va_list zamiast .... Wersje ... są tylko owijkami wokół wersji va_list.

Answer 3

W wspaniałej C++ 0x można użyć zmiennej liczbie argumentów szablony:

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 4

Można użyć inline zespół do wywołania funkcji. (w tym kodzie zakładam, że argumenty są znakami).

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 5

Variadic Functions może być dangerous. A oto bezpieczniejsza sztuczka:

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

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

Answer 6

Roztwór Rossa nieco oczyszczony. Działa tylko wtedy, gdy wszystkie argumenty są wskaźnikami. Również implementacja języka musi obsługiwać usuwanie 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);} 

Answer 7

Nie jestem pewien, czy to działa dla wszystkich kompilatorów, ale jak dotąd zadziałało to 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 go nie potrzebujesz. Działa, ponieważ va_start używa adresu danej zmiennej jako punktu początkowego. W tym przypadku podajemy odwołanie do zmiennej w func(). Więc używa tego adresu i czyta zmienne po tym na stosie. Funkcja inner_func() czyta 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ą działać, jeśli jako punkt wyjścia nadamy im dowolny var. Jeśli chcesz, możesz przekazać wskaźniki innym funkcjom i użyć ich również. Możesz łatwo tworzyć własne makra. Wszystkie makra są typowymi adresami pamięci. Jednak tworzenie ich dla wszystkich kompilatorów i konwencji wywoływania jest denerwujące. Więc generalnie łatwiej jest używać tych, które pochodzą z kompilatora.

Answer 8

Możesz także wypróbować makro.

#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 9

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

A może Ty?

Jeśli otoczysz funkcję wariadyczną w makrze, nie potrzebujesz poprzedzającego argumentu. Rozważmy następujący przykład:

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

To jest oczywiście o wiele bardziej wygodne, ponieważ nie musisz określić Pierwszym argumentem za każdym razem.