Melewati jumlah variabel argumen di sekitar

Katakanlah saya memiliki fungsi C yang mengambil sejumlah variabel argumen: Bagaimana saya bisa memanggil fungsi lain yang mengharapkan sejumlah variabel argumen dari dalamnya, melewati semua argumen yang masuk ke fungsi pertama?

Contoh:

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

Untuk meneruskan elips, Anda harus mengubahnya menjadi va_list dan menggunakannya va_list di fungsi kedua Anda. Secara khusus;

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

Tidak ada cara untuk memanggil (misalnya) printf tanpa mengetahui berapa banyak argumen yang Anda sampaikan, kecuali Anda ingin masuk ke trik nakal dan non-portabel.

Solusi yang umum digunakan adalah untuk selalu memberikan bentuk alternatif dari fungsi vararg, sehingga printfmemiliki vprintfyang va_listmenggantikan .... The ...versi hanya pembungkus sekitar va_listversi.

Fungsi Variadik bisa berbahaya . Ini trik yang lebih aman:

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

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

Dalam C ++ 0x yang luar biasa Anda bisa menggunakan templat 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...);
}

Anda dapat menggunakan unit inline untuk panggilan fungsi. (dalam kode ini saya menganggap argumen adalah karakter).

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

Anda dapat mencoba makro juga.

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

Meskipun Anda dapat menyelesaikan masalah pemasangan formatter dengan menyimpannya di buffer lokal terlebih dahulu, tetapi itu perlu stack dan terkadang bisa menjadi masalah untuk ditangani. Saya mencoba mengikuti dan tampaknya berfungsi dengan baik.

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

Semoga ini membantu.

Solusi Ross sedikit beres-beres. Hanya berfungsi jika semua argumen adalah pointer. Juga implementasi bahasa harus mendukung penghapusan koma sebelumnya jika __VA_ARGS__kosong (baik Visual Studio C ++ dan GCC lakukan).

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

Katakanlah Anda memiliki fungsi variadik khas yang Anda tulis. Karena setidaknya satu argumen diperlukan sebelum variadic ..., Anda harus selalu menulis argumen tambahan dalam penggunaan.

Atau apakah Anda

Jika Anda membungkus fungsi variadic Anda dalam makro, Anda tidak perlu arg sebelumnya. Pertimbangkan contoh ini:

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

Ini jelas jauh lebih nyaman, karena Anda tidak perlu menentukan argumen awal setiap kali.

Saya tidak yakin apakah ini bekerja untuk semua kompiler, tetapi sejauh ini berhasil bagi saya.

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

Anda dapat menambahkan ... ke inner_func () jika Anda mau, tetapi Anda tidak membutuhkannya. Ini berfungsi karena va_start menggunakan alamat variabel yang diberikan sebagai titik awal. Dalam hal ini, kami memberikan referensi ke variabel di func (). Jadi ia menggunakan alamat itu dan membaca variabel setelah itu di stack. Fungsi inner_func () membaca dari alamat stack dari func (). Jadi itu hanya berfungsi jika kedua fungsi menggunakan segmen stack yang sama.

Macro va_start dan va_arg umumnya akan berfungsi jika Anda memberi mereka var sebagai titik awal. Jadi jika mau, Anda bisa meneruskan pointer ke fungsi lain dan menggunakannya juga. Anda dapat membuat makro sendiri dengan cukup mudah. Semua makro lakukan adalah mengetikkan alamat memori. Namun membuat mereka bekerja untuk semua kompiler dan konvensi pemanggilan itu mengganggu. Jadi umumnya lebih mudah menggunakan yang datang dengan kompiler.