Pasar argumentos de variable a otra función que acepta una lista de argumentos de variable

Entonces tengo 2 funciones que ambas tienen argumentos similares

void example(int a, int b, ...);
void exampleB(int b, ...);

Ahora examplellama exampleB, pero ¿cómo puedo pasar las variables en la lista de argumentos de variable sin modificar exampleB(ya que esto ya se usa en otros lugares también)?

No puede hacerlo directamente; tienes que crear una función que tome un va_list:

#include <stdarg.h>

static void exampleV(int b, va_list args);

void exampleA(int a, int b, ...)    // Renamed for consistency
{
    va_list args;
    do_something(a);                // Use argument a somehow
    va_start(args, b);
    exampleV(b, args);
    va_end(args);
}

void exampleB(int b, ...)
{
    va_list args;
    va_start(args, b);
    exampleV(b, args);
    va_end(args);
}

static void exampleV(int b, va_list args)
{
    ...whatever you planned to have exampleB do...
    ...except it calls neither va_start nor va_end...
}

Tal vez arrojar una piedra en un estanque aquí, pero parece funcionar bastante bien con las plantillas variadas de C ++ 11:

#include <stdio.h>

template<typename... Args> void test(const char * f, Args... args) {
  printf(f, args...);
}

int main()
{
  int a = 2;
  test("%s\n", "test");
  test("%s %d %d %p\n", "second test", 2, a, &a);
}

Al menos, funciona con g++.

debe crear versiones de estas funciones que tomen un va_list y las pasen. Mire vprintfcomo ejemplo:

int vprintf ( const char * format, va_list arg );

También quería ajustar printf y encontré una respuesta útil aquí:

Cómo pasar un número variable de argumentos a printf / sprintf

No estaba interesado en absoluto en el rendimiento (estoy seguro de que este fragmento de código se puede mejorar de varias maneras, no dude en hacerlo :)), esto es solo para depuración general, así que hice esto:

//Helper function
std::string osprintf(const char *fmt, ...)
{
    va_list args;
    char buf[1000];
    va_start(args, fmt);
    vsnprintf(buf, sizeof(buf), fmt, args );
    va_end(args);
    return buf;
}

que luego puedo usar así

Point2d p;

cout << osprintf("Point2d: (%3i, %3i)", p.x, p.y);
instead of for example:
cout << "Point2d: ( " << setw(3) << p.x << ", " << p.y << " )";

Los ostreams de c ++ son hermosos en algunos aspectos, pero prácticamente se vuelven horribles si desea imprimir algo como esto con algunas cadenas pequeñas como paréntesis, dos puntos y comas insertadas entre los números.

Por cierto, muchas implementaciones de C tienen una variación interna de v? Printf que, en mi humilde opinión, debería haber sido parte del estándar C. Los detalles exactos varían, pero una implementación típica aceptará una estructura que contenga un puntero de función de salida de caracteres e información que indique lo que se supone que debe suceder. Esto permite que printf, sprintf y fprintf utilicen el mismo mecanismo 'central'. Por ejemplo, vsprintf podría ser algo como:

void s_out (PRINTF_INFO * p_inf, char ch)
{
  (* (p_inf-> destptr) ++) = ch;
  p_inf-> resultado ++;
}

int vsprintf (char * dest, const char * fmt, argumentos de lista_va)
{
  PRINTF_INFO p_inf;
  p_inf.destptr = dest;
  p_inf.result = 0;
  p_inf.func = s_out;
  core_printf (& p_inf, fmt, args);
}

La función core_printf entonces llama a p_inf-> func para cada carácter que se va a generar; la función de salida puede enviar los caracteres a la consola, un archivo, una cadena o algo más. Si la implementación de uno expone la función core_printf (y cualquier mecanismo de configuración que utilice), se puede extender con todo tipo de variaciones.

Una forma posible es usar #define:

#define exampleB(int b, ...)  example(0, b, __VA_ARGS__)

Basado en el comentario que está terminando vsprintf, y que esto está etiquetado como C ++, sugiero que no intente hacer esto, sino que cambie su interfaz para usar iostreams C ++ en su lugar. Tienen ventajas sobre la printlínea de funciones, como la seguridad de tipos y la posibilidad de imprimir elementos que printfno podrían manipularse. Un poco de retrabajo ahora podría ahorrar una cantidad significativa de dolor en el futuro.

Al usar el nuevo estándar C ++ 0x, es posible que pueda hacer esto usando plantillas variadas o incluso convertir ese código antiguo a la sintaxis de la nueva plantilla sin romper nada.

Esta es la única forma de hacerlo ... y la mejor forma de hacerlo también ...

static BOOL(__cdecl *OriginalVarArgsFunction)(BYTE variable1, char* format, ...)(0x12345678); //TODO: change address lolz

BOOL __cdecl HookedVarArgsFunction(BYTE variable1, char* format, ...)
{
    BOOL res;

    va_list vl;
    va_start(vl, format);

    // Get variable arguments count from disasm. -2 because of existing 'format', 'variable1'
    uint32_t argCount = *((uint8_t*)_ReturnAddress() + 2) / sizeof(void*) - 2;
    printf("arg count = %d\n", argCount);

    // ((int( __cdecl* )(const char*, ...))&oldCode)(fmt, ...);
    __asm
    {
        mov eax, argCount
        test eax, eax
        je noLoop
        mov edx, vl
        loop1 :
        push dword ptr[edx + eax * 4 - 4]
        sub eax, 1
        jnz loop1
        noLoop :
        push format
        push variable1
        //lea eax, [oldCode] // oldCode - original function pointer
        mov eax, OriginalVarArgsFunction
        call eax
        mov res, eax
        mov eax, argCount
        lea eax, [eax * 4 + 8] //+8 because 2 parameters (format and variable1)
        add esp, eax
    }
    return res;
}