Passando argumentos de variáveis ​​para outra função que aceita uma lista de argumentos de variáveis

Portanto, tenho 2 funções com argumentos semelhantes

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

Agora examplechama exampleB, mas como posso passar as variáveis ​​na lista de argumentos de variáveis ​​sem modificar exampleB(já que isso já é usado em outro lugar também).

Você não pode fazer isso diretamente; você tem que criar uma função que leva a 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...
}

Talvez jogar uma pedra em um lago aqui, mas parece funcionar muito bem com modelos variáveis ​​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);
}

No mínimo, funciona com g++.

você deve criar versões dessas funções que pegam uma va_list e as aprovar. Veja vprintfcomo um exemplo:

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

Eu também queria embrulhar printf e encontrei uma resposta útil aqui:

Como passar um número variável de argumentos para printf / sprintf

Eu não estava nem um pouco interessado em desempenho (tenho certeza que este pedaço de código pode ser melhorado de várias maneiras, fique à vontade para fazer isso :)), isso é apenas para depuração geral, então fiz o seguinte:

//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 eu então posso usar assim

Point2d p;

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

Os ostreams C ++ são bonitos em alguns aspectos, mas praticamente se tornam horríveis se você quiser imprimir algo assim com algumas pequenas strings como parênteses, dois pontos e vírgulas inseridos entre os números.

A propósito, muitas implementações C têm uma variação interna v? Printf que IMHO deveria ter feito parte do padrão C. Os detalhes exatos variam, mas uma implementação típica aceitará uma estrutura contendo um ponteiro de função de saída de caractere e informações dizendo o que deve acontecer. Isso permite que printf, sprintf e fprintf usem o mesmo mecanismo de 'núcleo'. Por exemplo, vsprintf pode 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, va_list args)
{
  PRINTF_INFO p_inf;
  p_inf.destptr = dest;
  p_inf.result = 0;
  p_inf.func = s_out;
  core_printf (& p_inf, fmt, args);
}

A função core_printf então chama p_inf-> func para cada caractere a ser gerado; a função de saída pode então enviar os caracteres para o console, um arquivo, uma string ou outra coisa. Se a implementação de alguém expõe a função core_printf (e qualquer mecanismo de configuração que ela usa), pode-se estendê-la com todos os tipos de variações.

Uma maneira possível é usar #define:

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

Com base no comentário que você está redigindo vsprintfe que está marcado como C ++, sugiro que não tente fazer isso, mas mude sua interface para usar iostreams C ++. Eles têm vantagens sobre a printlinha de funções, como segurança de digitação e capacidade de imprimir itens que printfnão dariam conta. Algum retrabalho agora pode evitar uma quantidade significativa de dor no futuro.

Usando o novo padrão C ++ 0x, você pode conseguir fazer isso usando modelos variados ou até mesmo converter o código antigo para a nova sintaxe de modelo sem quebrar nada.

Esta é a única forma de o fazer .. e a melhor forma de o fazer também ..

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