Cómo envolver una función con argumentos de longitud variable?

Question

Estoy buscando hacer esto en C/C++.

Me encontré con Variable Length Arguments pero esto sugiere una solución con Python & C usando libffi.

Ahora, si quiero envolver printf función con myprintf

Lo que hago es, como a continuación:

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

Pero los resultados no son los esperados!

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

¿En qué punto perdí?

Answer 1

el problema es que no se puede utilizar 'printf' con va_args. Debe usar vprintf si está utilizando listas de argumentos variables. VPrint, vsprintf, vfprintf, etc (hay también versiones 'seguros' en tiempo de ejecución C de Microsoft que evitarán desbordamientos de búfer, etc.)

Usted obras de la muestra de la siguiente manera:

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

Answer 2

¿Qué quiere decir una solución pura de C/C++?

El parámetro de reposo (...) es compatible con plataforma cruzada en el tiempo de ejecución de C.

http://msdn.microsoft.com/en-us/library/kb57fad8.aspx

Answer 3

¿Está utilizando C o C++? La próxima versión de C++, C++ 0x, admitirá variadic templates, que proporcionan una solución a ese problema.

Otra solución puede lograrse por el operador inteligente sobrecarga para lograr una sintaxis como esta:

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

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

Con el fin de conseguir que esto funcione, la clase varargs tiene que ser implementado para anular operator = que devuelve un objeto proxy que, a su vez, anula operator ,. Sin embargo, por lo que sé, hacer que este tipo de variante sea seguro en C++ actual no es posible, ya que tendría que funcionar por tipo de borrado.

Answer 4

También estoy seguro de lo que entendemos por pura

En C++ utilizamos

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

Answer 5

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); 
} 
If you're just trying to call printf, 
there's a printf variant called vprintf that takes 
the va_list directly : vprintf(fmt, args); 

Answer 6

En C++ 11 esta es una solución posible utilizando Variadic templates:

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

EDITAR

Como @rubenvb señala que hay consideraciones que considerar, por ejemplo, generará código para cada instancia que dará lugar a la saturación del código.

Answer 7

En realidad, hay una forma de llamar a una función que no tiene una versión va_list desde un contenedor.La idea es usar ensamblador, no tocar argumentos en la pila, y reemplazar temporalmente la dirección de retorno de la función.

Ejemplo para Visual C x86. call addr_printf llamadas 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 
    } 
}