Değişken sayıda argümanın aktarılması

Değişken sayıda bağımsız değişken alan bir C işlevim olduğunu varsayalım: İlk işleve gelen tüm bağımsız değişkenleri geçirerek değişken sayıda bağımsız değişken bekleyen başka bir işlevi nasıl arayabilirim?

Misal:

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

Elipsleri iletmek için bunları bir va_list'e dönüştürmeniz ve bu va_list'i ikinci fonksiyonunuzda kullanmanız gerekir. özellikle;

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

Yaramaz ve taşınabilir olmayan numaralara girmek istemediğiniz sürece, ona kaç argüman ilettiğinizi bilmeden printf'i çağırmanın bir yolu yoktur.

Genel olarak kullanılan solüsyon yüzden, her zaman vararg fonksiyonlarının alternatif bir biçimini sunmaktır printfsahip vprintfbir aldığı va_listyerine .... ...Versiyonları etrafına toplanmıştır va_listsürümleri.

Değişkin Fonksiyonlar olabilir tehlikeli . İşte daha güvenli bir numara:

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

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

Muhteşem C ++ 0x'de varyasyon şablonları kullanabilirsiniz:

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

İşlev çağrısı için satır içi montajı kullanabilirsiniz. (bu kodda argümanların karakter olduğunu varsayıyorum).

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

Makroyu da deneyebilirsiniz.

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

Biçimlendiriciyi önce yerel arabellekte saklayarak geçmeyi çözebilirsiniz, ancak bu yığına ihtiyaç duyar ve bazen başa çıkmak için sorun olabilir. Takip etmeyi denedim ve iyi çalışıyor gibi görünüyor.

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

Bu yardımcı olur umarım.

Ross'un çözümü biraz temizlendi. Yalnızca tüm argümanlar işaretçi ise çalışır. Ayrıca dil uygulaması __VA_ARGS__boşsa önceki virgülün elenmesini desteklemelidir (hem Visual Studio C ++ hem de GCC bunu yapar).

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

Diyelim ki, yazdığınız tipik bir varyasyon fonksiyonunuz var. Variadic olandan önce en az bir bağımsız değişken gerektiğinden ..., kullanımda her zaman fazladan bir bağımsız değişken yazmanız gerekir.

Yoksa sen mi?

Variadic işlevinizi bir makroya sarırsanız, önceki bağımsız değişkene ihtiyacınız yoktur. Bu örneği düşünün:

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

Her seferinde ilk argümanı belirtmeniz gerekmediği için bu çok daha uygundur.

Bunun tüm derleyiciler için işe yarayıp yaramadığından emin değilim, ama benim için şimdiye kadar çalıştı.

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

İsterseniz inner_func () öğesine ... ekleyebilirsiniz, ancak buna ihtiyacınız yoktur. Va_start, verilen değişkenin adresini başlangıç ​​noktası olarak kullandığı için çalışır. Bu durumda, func () içindeki bir değişkene bir referans veriyoruz. Böylece bu adresi kullanır ve bundan sonra değişkenleri yığında okur. İnner_func () işlevi func () 'in yığın adresinden okuyor. Bu nedenle, yalnızca her iki işlev de aynı yığın segmentini kullanıyorsa çalışır.

Va_start ve va_arg makroları, başlangıç ​​noktası olarak herhangi bir değişken verirseniz genellikle çalışır. İsterseniz işaretçileri diğer işlevlere geçirebilir ve bunları da kullanabilirsiniz. Kendi makrolarınızı kolayca yapabilirsiniz. Tüm makrolar tipik bellek adresleridir. Ancak onları tüm derleyiciler ve çağrışım kuralları için çalışmak sinir bozucu. Bu nedenle derleyici ile birlikte gelenleri kullanmak genellikle daha kolaydır.