Değişken bağımsız değişkenlerini, değişken bağımsız değişken listesini kabul eden başka bir işleve gönderme

Yani her ikisinin de benzer argümanları olan 2 fonksiyonum var

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

Şimdi exampleçağırıyor exampleB, ancak değişken bağımsız değişken listesindeki değişkenleri değiştirmeden nasıl iletebilirim exampleB(bu zaten başka yerlerde de kullanıldığından).

Bunu doğrudan yapamazsınız; aşağıdakileri alan bir işlev oluşturmanız gerekir 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...
}

Belki burada bir havuza bir kaya fırlatabiliriz, ancak C ++ 11 çeşitli şablonlarla oldukça iyi çalışıyor gibi görünüyor:

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

En azından birlikte çalışıyor g++.

bir va_list alan bu işlevlerin sürümlerini oluşturmalı ve bunları iletmelisiniz. vprintfÖrnek olarak bakın :

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

Ayrıca printf'i paketlemek istedim ve burada yararlı bir yanıt buldum:

Printf / sprintf'e değişken sayıda bağımsız değişken nasıl iletilir

Performansla hiç ilgilenmedim (eminim bu kod parçası birkaç şekilde geliştirilebilir, bunu yapmaktan çekinmeyin :)), bu sadece genel hata ayıklama için, bu yüzden şunu yaptım:

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

daha sonra bunun gibi kullanabilirim

Point2d p;

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

C ++ ostreams bazı yönlerden güzeldir, ancak parantez, iki nokta üst üste ve sayılar arasına virgül gibi bazı küçük dizeler ekleyerek böyle bir şey yazdırmak istiyorsanız pratikte korkunç olur.

Bu arada, birçok C uygulamasında, IMHO'nun C standardının bir parçası olması gereken dahili bir v? Printf varyasyonu vardır. Kesin ayrıntılar değişebilir, ancak tipik bir uygulama, bir karakter-çıktı fonksiyon göstericisi ve ne olması gerektiğini söyleyen bilgileri içeren bir yapıyı kabul edecektir. Bu, printf, sprintf ve fprintf'in hepsinin aynı 'core' mekanizmasını kullanmasına izin verir. Örneğin, vsprintf şöyle bir şey olabilir:

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

int vsprintf (char * dest, const char * fmt, va_list değiştirgeler)
{
  PRINTF_INFO p_inf;
  p_inf.destptr = dest;
  p_inf.result = 0;
  p_inf.func = s_out;
  core_printf (ve p_inf fmt args);
}

Core_printf işlevi çıktı alınacak her karakter için p_inf-> func'u çağırır; çıktı işlevi daha sonra karakterleri konsola, bir dosyaya, dizgeye veya başka bir şeye gönderebilir. Bir kişinin gerçeklemesi, core_printf işlevini (ve kullandığı kurulum mekanizmasını) açığa çıkarırsa, onu her çeşit varyasyonla genişletebilir.

Olası bir yol, #define kullanmaktır:

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

Sarmaladığınız yoruma vsprintfve bunun C ++ olarak etiketlendiğine dayanarak, bunu yapmayı denememenizi öneririm, ancak arayüzünüzü bunun yerine C ++ iostreams kullanacak şekilde değiştirin. printTür güvenliği ve printfüstesinden gelemeyecek öğeleri yazdırabilme gibi işlevlere göre avantajları vardır . Şimdi bazı yeniden çalışmalar, gelecekte önemli miktarda acıdan kurtarabilir.

Yeni C ++ 0x standardını kullanarak, bunu çeşitli şablonlar kullanarak yapabilir veya hatta bu eski kodu hiçbir şeyi bozmadan yeni şablon sözdizimine dönüştürebilirsiniz.

Bunu yapmanın tek yolu bu .. ve bunu yapmanın da en iyi yolu ..

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