在C中，是否可以转发可变函数的调用？如，
int my_printf(char *fmt, ...) {
fprintf(stderr, "Calling printf with fmt %s", fmt);
return SOMEHOW_INVOKE_LIBC_PRINTF;
}
在这种情况下，以上述方式转发调用显然不是必需的（因为您可以通过其他方式记录调用，或使用vfprintf），但我正在处理的代码库要求包装器做一些实际的工作，并且没有（并且不能添加）类似于vfprintf的辅助函数。
[更新：基于迄今为止提供的答案，似乎存在一些混淆。用另一种方式表达问题：通常，你可以包装一些任意的可变参数函数而不修改该函数的定义。]
答案 0 :(得分：143)
如果您没有类似于vfprintf的功能，需要va_list而不是可变数量的参数，您不能这样做。请参阅 http://c-faq.com/varargs/handoff.html。
示例：
void myfun(const char *fmt, va_list argp) {
vfprintf(stderr, fmt, argp);
}
答案 1 :(得分：55)
不是直接的，但是变量函数与varargs样式替代函数成对出现是常见的（并且在标准库中几乎普遍存在这种情况）。例如printf / vprintf
v ...函数采用va_list参数，其实现通常使用编译器特定的“宏魔法”来完成，但是你可以保证从像这样的可变参数函数调用v ...样式函数将起作用：
#include <stdarg.h>
int m_printf(char *fmt, ...)
{
int ret;
/* Declare a va_list type variable */
va_list myargs;
/* Initialise the va_list variable with the ... after fmt */
va_start(myargs, fmt);
/* Forward the '...' to vprintf */
ret = vprintf(fmt, myargs);
/* Clean up the va_list */
va_end(myargs);
return ret;
}
这应该会给你你正在寻找的效果。
如果您正在考虑编写可变参数库函数，您还应该考虑将va_list样式伴随作为库的一部分提供。从您的问题中可以看出，它可以证明对您的用户有用。
答案 2 :(得分：43)
C99支持macros with variadic arguments;根据您的编译器，您可能能够声明一个执行您想要的宏：
#define my_printf(format, ...) \
do { \
fprintf(stderr, "Calling printf with fmt %s\n", format); \
some_other_variadac_function(format, ##__VA_ARGS__); \
} while(0)
一般来说，最好的解决方案是使用你想要包装的函数的 va_list 形式，如果存在的话。
答案 3 :(得分：11)
几乎使用<stdarg.h>中的可用设施：
#include <stdarg.h>
int my_printf(char *format, ...)
{
va_list args;
va_start(args, format);
int r = vprintf(format, args);
va_end(args);
return r;
}
请注意，您需要使用vprintf版本而不是普通printf。在没有使用va_list的情况下，没有办法在这种情况下直接调用可变参数函数。
答案 4 :(得分：10)
由于不可能以一种很好的方式转发这样的调用，我们通过设置一个带有原始堆栈帧副本的新堆栈帧来解决这个问题。然而，这是高度不可移植并且做出各种假设，例如该代码使用帧指针和“标准”调用约定。
此头文件允许为x86_64和i386（GCC）包装可变参数函数。它不适用于浮点参数，但应该直接扩展以支持这些参数。
#ifndef _VA_ARGS_WRAPPER_H
#define _VA_ARGS_WRAPPER_H
#include <limits.h>
#include <stdint.h>
#include <alloca.h>
#include <inttypes.h>
#include <string.h>
/* This macros allow wrapping variadic functions.
* Currently we don't care about floating point arguments and
* we assume that the standard calling conventions are used.
*
* The wrapper function has to start with VA_WRAP_PROLOGUE()
* and the original function can be called by
* VA_WRAP_CALL(function, ret), whereas the return value will
* be stored in ret. The caller has to provide ret
* even if the original function was returning void.
*/
#define __VA_WRAP_CALL_FUNC __attribute__ ((noinline))
#define VA_WRAP_CALL_COMMON() \
uintptr_t va_wrap_this_bp,va_wrap_old_bp; \
va_wrap_this_bp = va_wrap_get_bp(); \
va_wrap_old_bp = *(uintptr_t *) va_wrap_this_bp; \
va_wrap_this_bp += 2 * sizeof(uintptr_t); \
size_t volatile va_wrap_size = va_wrap_old_bp - va_wrap_this_bp; \
uintptr_t *va_wrap_stack = alloca(va_wrap_size); \
memcpy((void *) va_wrap_stack, \
(void *)(va_wrap_this_bp), va_wrap_size);
#if ( __WORDSIZE == 64 )
/* System V AMD64 AB calling convention */
static inline uintptr_t __attribute__((always_inline))
va_wrap_get_bp()
{
uintptr_t ret;
asm volatile ("mov %%rbp, %0":"=r"(ret));
return ret;
}
#define VA_WRAP_PROLOGUE() \
uintptr_t va_wrap_ret; \
uintptr_t va_wrap_saved_args[7]; \
asm volatile ( \
"mov %%rsi, (%%rax)\n\t" \
"mov %%rdi, 0x8(%%rax)\n\t" \
"mov %%rdx, 0x10(%%rax)\n\t" \
"mov %%rcx, 0x18(%%rax)\n\t" \
"mov %%r8, 0x20(%%rax)\n\t" \
"mov %%r9, 0x28(%%rax)\n\t" \
: \
:"a"(va_wrap_saved_args) \
);
#define VA_WRAP_CALL(func, ret) \
VA_WRAP_CALL_COMMON(); \
va_wrap_saved_args[6] = (uintptr_t)va_wrap_stack; \
asm volatile ( \
"mov (%%rax), %%rsi \n\t" \
"mov 0x8(%%rax), %%rdi \n\t" \
"mov 0x10(%%rax), %%rdx \n\t" \
"mov 0x18(%%rax), %%rcx \n\t" \
"mov 0x20(%%rax), %%r8 \n\t" \
"mov 0x28(%%rax), %%r9 \n\t" \
"mov $0, %%rax \n\t" \
"call *%%rbx \n\t" \
: "=a" (va_wrap_ret) \
: "b" (func), "a" (va_wrap_saved_args) \
: "%rcx", "%rdx", \
"%rsi", "%rdi", "%r8", "%r9", \
"%r10", "%r11", "%r12", "%r14", \
"%r15" \
); \
ret = (typeof(ret)) va_wrap_ret;
#else
/* x86 stdcall */
static inline uintptr_t __attribute__((always_inline))
va_wrap_get_bp()
{
uintptr_t ret;
asm volatile ("mov %%ebp, %0":"=a"(ret));
return ret;
}
#define VA_WRAP_PROLOGUE() \
uintptr_t va_wrap_ret;
#define VA_WRAP_CALL(func, ret) \
VA_WRAP_CALL_COMMON(); \
asm volatile ( \
"mov %2, %%esp \n\t" \
"call *%1 \n\t" \
: "=a"(va_wrap_ret) \
: "r" (func), \
"r"(va_wrap_stack) \
: "%ebx", "%ecx", "%edx" \
); \
ret = (typeof(ret))va_wrap_ret;
#endif
#endif
最后你可以像这样包装：
int __VA_WRAP_CALL_FUNC wrap_printf(char *str, ...)
{
VA_WRAP_PROLOGUE();
int ret;
VA_WRAP_CALL(printf, ret);
printf("printf returned with %d \n", ret);
return ret;
}
答案 5 :(得分：3)
使用vfprintf：
int my_printf(char *fmt, ...) {
va_list va;
int ret;
va_start(va, fmt);
ret = vfprintf(stderr, fmt, va);
va_end(va);
return ret;
}
答案 6 :(得分：2)
无法转发此类函数调用，因为您可以检索原始堆栈元素的唯一位置是my_print()。包装调用的通常方法是有两个函数，一个只是将参数转换为各种varargs结构，另一个实际操作这些结构。使用这样的双功能模型，您可以（例如）通过使用printf()初始化my_printf()中的结构来包装va_start()，然后将它们传递给vfprintf()。
答案 7 :(得分：2)
gcc提供了可以执行此操作的扩展名：__builtin_apply和亲戚。请参阅gcc手册中的Constructing Function Calls。
一个例子：
#include <stdio.h>
int my_printf(const char *fmt, ...) {
void *args = __builtin_apply_args();
printf("Hello there! Format string is %s\n", fmt);
void *ret = __builtin_apply((void (*)())printf, args, 1000);
__builtin_return(ret);
}
int main(void) {
my_printf("%d %f %s\n", -37, 3.1415, "spam");
return 0;
}
文档中有一些注意事项，它可能在更复杂的情况下不起作用。而且，您必须对参数的最大大小进行硬编码（这里我使用了1000）。但这可能是其他以C或汇编语言剖析堆栈的方法的合理选择。
答案 8 :(得分：1)
对于偏离主题的咆哮感到抱歉，但是：
元问题在于C语言中的varargs接口从一开始就从根本上被打破了。这是一个缓冲溢出和无效内存访问的邀请，因为如果没有明确的结束信号（没有人真正使用懒惰），就无法找到参数列表的末尾。它总是依赖于深奥的特定于实现的宏，只有某些架构支持重要的va_copy（）宏。
答案 9 :(得分：1)
是的，你可以做到，但它有些难看，你必须知道最大数量的参数。此外，如果您所在的体系结构中参数未在x86上传递（例如，PowerPC），则必须知道是否使用了“特殊”类型（double，floats，altivec等）以及是否所以，相应地处理它们。它很快就会很痛苦，但是如果你使用的是x86，或者如果原始功能有一个定义明确且有限的边界，它可以工作。 它仍然是一个黑客，用于调试目的。不要围绕它建立你的软件。 无论如何，这是一个关于x86的工作示例：
#include <stdio.h>
#include <stdarg.h>
int old_variadic_function(int n, ...)
{
va_list args;
int i = 0;
va_start(args, n);
if(i++<n) printf("arg %d is 0x%x\n", i, va_arg(args, int));
if(i++<n) printf("arg %d is %g\n", i, va_arg(args, double));
if(i++<n) printf("arg %d is %g\n", i, va_arg(args, double));
va_end(args);
return n;
}
int old_variadic_function_wrapper(int n, ...)
{
va_list args;
int a1;
int a2;
int a3;
int a4;
int a5;
int a6;
int a7;
int a8;
/* Do some work, possibly with another va_list to access arguments */
/* Work done */
va_start(args, n);
a1 = va_arg(args, int);
a2 = va_arg(args, int);
a3 = va_arg(args, int);
a4 = va_arg(args, int);
a5 = va_arg(args, int);
a6 = va_arg(args, int);
a7 = va_arg(args, int);
va_end(args);
return old_variadic_function(n, a1, a2, a3, a4, a5, a6, a7, a8);
}
int main(void)
{
printf("Call 1: 1, 0x123\n");
old_variadic_function(1, 0x123);
printf("Call 2: 2, 0x456, 1.234\n");
old_variadic_function(2, 0x456, 1.234);
printf("Call 3: 3, 0x456, 4.456, 7.789\n");
old_variadic_function(3, 0x456, 4.456, 7.789);
printf("Wrapped call 1: 1, 0x123\n");
old_variadic_function_wrapper(1, 0x123);
printf("Wrapped call 2: 2, 0x456, 1.234\n");
old_variadic_function_wrapper(2, 0x456, 1.234);
printf("Wrapped call 3: 3, 0x456, 4.456, 7.789\n");
old_variadic_function_wrapper(3, 0x456, 4.456, 7.789);
return 0;
}
出于某种原因，你不能使用带有va_arg的浮点数，gcc说它们被转换为double但是程序崩溃了。仅这一点就证明了这个解决方案是一个黑客攻击，而且没有通用的解决方案。 在我的例子中，我假设参数的最大数量是8，但你可以增加这个数字。包装函数也只使用整数，但它与其他“普通”参数的工作方式相同，因为它们总是转换为整数。目标函数将知道它们的类型，但您的中间包装器不需要。包装器也不需要知道正确数量的参数，因为目标函数也会知道它。 要做有用的工作（除了记录呼叫），你可能必须知道两者。
答案 10 :(得分：0)
基本上有三种选择。
一个是不传递它，而是使用目标函数的可变参数实现而不传递省略号。另一个是使用可变参数宏。第三种选择是我所缺少的所有东西。
我通常选择选项一，因为我觉得这很容易处理。选项二有一个缺点，因为调用可变参数宏有一些限制。
以下是一些示例代码：
#include <stdio.h>
#include <stdarg.h>
#define Option_VariadicMacro(f, ...)\
printf("printing using format: %s", f);\
printf(f, __VA_ARGS__)
int Option_ResolveVariadicAndPassOn(const char * f, ... )
{
int r;
va_list args;
printf("printing using format: %s", f);
va_start(args, f);
r = vprintf(f, args);
va_end(args);
return r;
}
void main()
{
const char * f = "%s %s %s\n";
const char * a = "One";
const char * b = "Two";
const char * c = "Three";
printf("---- Normal Print ----\n");
printf(f, a, b, c);
printf("\n");
printf("---- Option_VariadicMacro ----\n");
Option_VariadicMacro(f, a, b, c);
printf("\n");
printf("---- Option_ResolveVariadicAndPassOn ----\n");
Option_ResolveVariadicAndPassOn(f, a, b, c);
printf("\n");
}
答案 11 :(得分：0)
做到这一点的最好方法是
var ms = new MemoryStream();
// parse range header...
var range = new HttpRange(from, to);
BlobDownloadInfo info = await blobClient.DownloadAsync(range);
await info.Content.CopyToAsync(ms);
ms.Position = 0;//ms is positioned at the end of the stream so we need to reset that.
return ms;
答案 12 :(得分：0)
不确定这是否有助于回答OP的问题，因为我不知道为什么在包装函数中使用类似于vfprintf的辅助函数的限制适用。我认为这里的关键问题是在不解释它们的情况下转发可变参数列表很困难。可能的是执行格式化（使用类似于vfprintf：vsnprintf的辅助函数）并将格式化后的输出与可变参数一起转发给包装函数（即不修改包装函数的定义）。所以，我们开始：
#include <stdio.h>
#include <stdarg.h>
int my_printf(char *fmt, ...)
{
if (fmt == NULL) {
/* Invalid format pointer */
return -1;
} else {
va_list args;
int len;
/* Initialize a variable argument list */
va_start(args, fmt);
/* Get length of format including arguments */
len = vsnprintf(NULL, 0, fmt, args);
/* End using variable argument list */
va_end(args);
if (len < 0) {
/* vsnprintf failed */
return -1;
} else {
/* Declare a character buffer for the formatted string */
char formatted[len + 1];
/* Initialize a variable argument list */
va_start(args, fmt);
/* Write the formatted output */
vsnprintf(formatted, sizeof(formatted), fmt, args);
/* End using variable argument list */
va_end(args);
/* Call the wrapped function using the formatted output and return */
fprintf(stderr, "Calling printf with fmt %s", fmt);
return printf("%s", formatted);
}
}
}
int main()
{
/* Expected output: Test
* Expected error: Calling printf with fmt Test
*/
my_printf("Test\n");
//printf("Test\n");
/* Expected output: Test
* Expected error: Calling printf with fmt %s
*/
my_printf("%s\n", "Test");
//printf("%s\n", "Test");
/* Expected output: %s
* Expected error: Calling printf with fmt %s
*/
my_printf("%s\n", "%s");
//printf("%s\n", "%s");
return 0;
}
我遇到了此解决方案here。
已修改：修正了egmont指出的错误