将变量 arguments 传递给另一个接受变量参数列表的 function

Question

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

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 并在这里找到了一个有用的答案：

如何将可变数量的参数传递给 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

顺便说一句，许多 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 6

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

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

Answer 7

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

Answer 8

使用 GNU C 扩展：

int FIRST_FUNC(...){
    __builtin_return(
        __builtin_apply(
            (void(*)())SECOND_FUNC, __builtin_apply_args(), 100));
}

还使用_builtin_return克隆返回值。

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

Answer 11

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

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

当你实现一个调用logger的wrapper logger ，我们可以先用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);
}

不是最干净的，但有效。 当您必须避免使用宏函数时，试试这个。