将可变参数传递给另一个接受可变参数列表的函数

Question

所以我有 2 个函数都有相似的参数

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

现在example 调用exampleB，但是如何在不修改exampleB 的情况下传递变量参数列表中的变量（因为这也已在其他地方使用过）。

Answer 1

你不能直接做；你必须创建一个接受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...
}

Answer 2

也许在这里往池塘里扔一块石头，但它似乎与 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);
}

至少，它适用于g++。

Answer 3

您应该创建带有 va_list 的这些函数的版本，并传递它们。以vprintf为例：

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

Answer 4

我也想包装 printf 并在这里找到了一个有用的答案：

How to pass variable number of arguments to printf/sprintf

我对性能完全不感兴趣（我确信这段代码可以通过多种方式改进，请随意这样做:)），这仅用于一般调试打印，所以我这样做了：

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

然后我可以像这样使用它

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 在某些方面很漂亮，但如果你想打印这样的东西，在数字之间插入一些小字符串，如括号、冒号和逗号，那实际上就变得可怕了。

Answer 5

一种可能的方法是使用#define:

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

Answer 6

顺便说一句，许多 C 实现都有一个内部 v?printf 变体，恕我直言，它应该是 C 标准的一部分。确切的细节各不相同，但典型的实现将接受一个包含字符输出函数指针和说明应该发生什么的信息的结构。这允许 printf、sprintf 和 fprintf 都使用相同的“核心”机制。例如，vsprintf 可能类似于：

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

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

core_printf 函数然后为每个要输出的字符调用 p_inf->func；然后输出函数可以将字符发送到控制台、文件、字符串或其他东西。如果一个人的实现公开了 core_printf 函数（以及它使用的任何设置机制），则可以使用各种变体对其进行扩展。

Answer 7

根据您包装vsprintf 的评论，并且这被标记为C++，我建议不要尝试这样做，而是更改您的界面以使用C++ iostreams。它们比print 功能线具有优势，例如类型安全以及能够打印printf 无法处理的项目。现在的一些返工可以在未来减少大量的痛苦。

Answer 8

这可能与此处描述的情况不完全相同，但如果您要为字符串格式函数（例如记录器）定义包装器：

void logger(const char *name, const char *format, ...);
void wrapper(const char *format, ...);

当您实现一个调用logger 的wrapper 时，我们可以先用vasprintf 创建一个字符串，然后将其传递给logger。

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

static void wrapper(const char *format, ...)
{
    char *string;
    va_list args;
    va_start(args, format);

    // variadic printf with allocated string. must free()
    vasprintf(&string, format, args);
    logger("wrapper", "%s", string);

    free(string);
    va_end(args);
}

不是最干净的，但有效。当您必须避免使用 macro 函数时，请尝试此操作。

Answer 9

使用新的 C++0x 标准，您可以使用可变参数模板完成这项工作，甚至可以将旧代码转换为新模板语法而不会破坏任何内容。

Answer 10

这是唯一的方法..也是最好的方法..

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