Wie kann ich eine Funktion mit Argumenten variabler Länge umschließen?

Ich schaue, um dies in C/C++ zu tun. Ich bin gestoßen Argumente mit variabler Längeaber dies schlägt eine Lösung mit Python und C vor libffi.

Nun, wenn ich das wickeln will printf Funktion mit myprintf.

Ich mache es wie folgt:

void myprintf(char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    printf(fmt, args);
    va_end(args);
}

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 9;
    int b = 10;
    char v = 'C';
    myprintf("This is a number: %d and \nthis is a character: %c and \n another number: %d\n", a, v, b);
    return 0;
}

Aber die Ergebnisse sind nicht wie erwartet!

This is a number: 1244780 and
this is a character: h and
another number: 29953463

Was habe ich verpasst?

Das Problem ist, dass Sie ‘printf’ nicht mit verwenden können va_args. Sie müssen verwenden vprintf wenn Sie variable Argumentlisten verwenden. vprint, vsprintf, vfprintfusw. (es gibt auch “sichere” Versionen in Microsofts C-Laufzeitumgebung, die Pufferüberläufe usw. verhindern.)

Sie probieren Werke wie folgt aus:

void myprintf(char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
}

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 9;
    int b = 10;
    char v = 'C';
    myprintf("This is a number: %d and \nthis is a character: %c and \n another number: %d\n", a, v, b);
    return 0;
}

Im C++11dies ist eine mögliche Lösung mit abwechslungsreiche Vorlagen:

template<typename... Args>
void myprintf(const char* fmt, Args... args)
{
    std::printf(fmt, args...);
}

Wie rubenvb betont, sind Kompromisse zu berücksichtigen. Beispielsweise generieren Sie Code für jede Instanz, was zu Code-Bloat führt.

Ich bin mir auch nicht sicher, was du mit rein meinst.

In C++ verwenden wir:

#include <cstdarg>
#include <cstdio>

class Foo
{   
    void Write(const char* pMsg, ...);
};

void Foo::Write( const char* pMsg, ...)
{
    char buffer[4096];
    std::va_list arg;
    va_start(arg, pMsg);
    std::vsnprintf(buffer, 4096, pMsg, arg);
    va_end(arg);
    ...
}

Tatsächlich gibt es eine Möglichkeit, eine Funktion aufzurufen, die kein hat va_list Version aus einem Wrapper. Die Idee ist, Assembler zu verwenden, Argumente auf dem Stapel nicht zu berühren und die Rückgabeadresse der Funktion vorübergehend zu ersetzen.

Ein Beispiel für Visual C x86. call addr_printf Anrufe printf():

__declspec( thread ) static void* _tls_ret;

static void __stdcall saveret(void *retaddr) {
    _tls_ret = retaddr;
}

static void* __stdcall _getret() {
    return _tls_ret;
}

__declspec(naked)
static void __stdcall restret_and_return_int(int retval) {
    __asm {
        call _getret
        mov [esp], eax   ; /* replace current retaddr with saved */
        mov eax, [esp+4] ; /* retval */
        ret 4
    }
}

static void __stdcall _dbg_printf_beg(const char *fmt, va_list args) {
    printf("calling printf(\"%s\")\n", fmt);
}

static void __stdcall _dbg_printf_end(int ret) {
    printf("printf() returned %d\n", ret);
}

__declspec(naked)
int dbg_printf(const char *fmt, ...)
{
    static const void *addr_printf = printf;
    /* prolog */
    __asm {
        push ebp
        mov  ebp, esp
        sub  esp, __LOCAL_SIZE
        nop
    }
    {
        va_list args;
        va_start(args, fmt);
        _dbg_printf_beg(fmt, args);
        va_end(args);
    }
    /* epilog */
    __asm {
        mov  esp, ebp
        pop  ebp
    }
    __asm  {
        call saveret
        call addr_printf
        push eax
        push eax
        call _dbg_printf_end
        call restret_and_return_int
    }
}

Benutzt du C oder C++? Die nächste C++-Version, C++0x, wird unterstützt abwechslungsreiche Vorlagen die eine Lösung für dieses Problem bieten.

Eine weitere Problemumgehung kann durch geschicktes Überladen von Operatoren erreicht werden, um eine Syntax wie die folgende zu erreichen:

void f(varargs va) {
    BOOST_FOREACH(varargs::iterator i, va)
        cout << *i << " ";
}

f(args = 1, 2, 3, "Hello");

Damit das funktioniert, muss die Klasse varargs muss zum Überschreiben implementiert werden operator = das ein Proxy-Objekt zurückgibt, das wiederum überschreibt operator ,. Allerdings ist es meines Wissens nicht möglich, diesen Variantentyp in aktuellem C++ sicher zu machen, da es durch Typlöschung funktionieren müsste.

Wie meinen Sie eine reine C/C++-Lösung?

Der rest-Parameter (…) wird in der C-Laufzeit plattformübergreifend unterstützt.

va_arg, va_copy, va_end, va_start

void myprintf(char* fmt, ...)
{
    va_ list args;
    va_ start(args, fmt);
    printf(fmt, args); // This is the fault. "vprintf(fmt, args);"
                       // should have been used.
    va_ end(args);
}

Wenn Sie nur versuchen anzurufen DruckfDa ist ein Druckf Variante genannt vprintf das nimmt die va_liste direkt: vprintf(fmt, args);