blocks|key|111511|text|什么是纯C/C%2B%2B解决方案？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111512|rest参数(.)在C运行时中支持跨平台。|111513|https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/va-arg-va-copy-va-end-va-start|offset|length|111514|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2O|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

How do you mean a pure C/C++ solution?
The rest parameter (...) is supported cross platform in the C runtime.
<a href="https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/va-arg-va-copy-va-end-va-start" rel="nofollow noreferrer">va_arg, va_copy, va_end, va_start</a>

blocks|key|111570|text|你用的是C还是C%2B%2B？下一个C%2B%2B版本，C%2B%2B0x，将支持为该问题提供解决方案的可变模板。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|111571|另一种解决方法可以通过聪明的操作符重载来实现如下语法：|111572|void+f(varargs+va)+{
++++BOOST_FOREACH(varargs::iterator+i,+va)
++++++++cout+<<+*i+<<+"+";
}

f(args+=+1,+2,+3,+"Hello");|code-block|syntax|javascript|111573|为了使其工作，必须实现类varargs以覆盖返回代理对象的operator+=，该代理对象反过来重写operator+,。然而，据我所知，在当前的C%2B%2B中使这种变体类型安全是不可能的，因为它必须通过类型擦除来工作。|style|CODE|111574|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Varargs#Variadic_functions_in_C.2C_Objective-C_and_C.2B.2B^0|14|4|0|0|0|0|C|7|T|A|1E|A|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@$A|13|B|14|M|N]|$A|15|B|16|M|N]|$A|17|B|18|M|N]]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Are you using C or C++? The next C++ version, C++0x, will support <a href="http://en.wikipedia.org/wiki/Varargs#Variadic_functions_in_C.2C_Objective-C_and_C.2B.2B" rel="nofollow noreferrer">variadic templates</a> which provide a solution to that problem.

Another workaround can be achieved by clever operator overloading to achieve a syntax like this:

<pre><code>void f(varargs va) {
 BOOST_FOREACH(varargs::iterator i, va)
 cout &lt;&lt; *i &lt;&lt; " ";
}

f(args = 1, 2, 3, "Hello");
</code></pre>

In order to get this to work, the class <code>varargs</code> has to be implemented to override <code>operator =</code> that returns a proxy object which, in turn, overrides <code>operator ,</code>. However, making this variant type safe in current C++ isn't possible as far as I know since it would have to work by type erasure.

blocks|key|818648|text|我也不知道你所说的纯洁是什么意思。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|818649|在C%2B%2B中，我们使用：|818650|#include+<cstdarg>
#include+<cstdio>

class+Foo
{+++
++++void+Write(const+char*+pMsg,+...);
};

void+Foo::Write(+const+char*+pMsg,+...)
{
++++char+buffer[4096];
++++std::va_list+arg;
++++va_start(arg,+pMsg);
++++std::vsnprintf(buffer,+4096,+pMsg,+arg);
++++va_end(arg);
++++...
}|code-block|syntax|javascript|818651|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I am also unsure what you mean by pure.
In C++ we use:
<pre><code>#include &lt;cstdarg&gt;
#include &lt;cstdio&gt;

class Foo
{ 
 void Write(const char* pMsg, ...);
};

void Foo::Write( const char* pMsg, ...)
{
 char buffer[4096];
 std::va_list arg;
 va_start(arg, pMsg);
 std::vsnprintf(buffer, 4096, pMsg, arg);
 va_end(arg);
 ...
}
</code></pre>

blocks|key|1110820|text|问题是您不能在va_args中使用“printf”。如果使用变量参数列表，则必须使用vprintf。vprint、vsprintf、vfprintf等(Microsoft的C运行时中也有防止缓冲区溢出的“安全”版本，等等)|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1110821|您的示例工作如下：|1110822|void+myprintf(char*+fmt,+...)
{
++++va_list+args;
++++va_start(args,+fmt);
++++vprintf(fmt,+args);
++++va_end(args);
}

int+_tmain(int+argc,+_TCHAR*+argv[])
{
++++int+a+=+9;
++++int+b+=+10;
++++char+v+=+'C';
++++myprintf("This+is+a+number:+%25d+and+\nthis+is+a+character:+%25c+and+\n+another+number:+%25d\n",+a,+v,+b);
++++return+0;
}|code-block|syntax|javascript|1110823|entityMap^0|16|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

The problem is that you cannot use 'printf' with va_args. You must use vprintf if you are using variable argument lists. vprint, vsprintf, vfprintf, etc. (there are also 'safe' versions in Microsoft's C runtime that will prevent buffer overruns, etc.)
You sample works as follows:
<pre><code>void myprintf(char* fmt, ...)
{
 va_list args;
 va_start(args, fmt);
 vprintf(fmt, args);
 va_end(args);
}

int _tmain(int argc, _TCHAR* argv[])
{
 int a = 9;
 int b = 10;
 char v = 'C';
 myprintf(&quot;This is a number: %d and \nthis is a character: %c and \n another number: %d\n&quot;, a, v, b);
 return 0;
}
</code></pre>

blocks|key|111660|text|void+myprintf(char*+fmt,+...)
{
++++va_+list+args;
++++va_+start(args,+fmt);
++++printf(fmt,+args);+//+This+is+the+fault.+"vprintf(fmt,+args);"
+++++++++++++++++++++++//+should+have+been+used.
++++va_+end(args);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|111661|如果您只是试图调用printf，有一个名为vprintf的printf变量，它直接接受va_list+:+vprintf(fmt，args)；|unstyled|111662|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>void myprintf(char* fmt, ...)
{
 va_ list args;
 va_ start(args, fmt);
 printf(fmt, args); // This is the fault. &quot;vprintf(fmt, args);&quot;
 // should have been used.
 va_ end(args);
}
</code></pre>
If you're just trying to call printf,
there's a printf variant called vprintf that takes
the va_list directly: vprintf(fmt, args);

blocks|key|822776|text|在C%2B%2B11中，这是使用可变模板的一种可能的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|822777|template<typename...+Args>
void+myprintf(const+char*+fmt,+Args...+args)
{
++++std::printf(fmt,+args...);
}|code-block|syntax|javascript|822778|作为鲁本夫指出，需要考虑的是权衡。例如，您将为每个实例生成代码，这将导致代码膨胀。|822779|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/C%252B%252B11|1|http://en.cppreference.com/w/cpp/language/parameter_pack|2|https://stackoverflow.com/questions/41400/how-can-i-wrap-a-function-with-variable-length-arguments#comment26036756_41400^0|1|5|0|C|4|1|0|0|2|5|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

In <a href="https://en.wikipedia.org/wiki/C%2B%2B11" rel="nofollow noreferrer">C++11</a>, this is one possible solution using <a href="http://en.cppreference.com/w/cpp/language/parameter_pack" rel="nofollow noreferrer">variadic templates</a>:
<pre><code>template&lt;typename... Args&gt;
void myprintf(const char* fmt, Args... args)
{
 std::printf(fmt, args...);
}
</code></pre>
As <a href="https://stackoverflow.com/questions/41400/how-can-i-wrap-a-function-with-variable-length-arguments#comment26036756_41400">rubenvb points out</a>, there are trade-offs to consider. For example, you will be generating code for each instance which will lead to code bloat.

blocks|key|111760|text|实际上，有一种方法可以调用没有包装器中的va_list版本的函数。这样做的目的是使用汇编程序，不要触摸堆栈上的参数，并临时替换函数返回地址。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|111761|Visual+x86的一个示例。call+addr_printf调用printf()|111762|__declspec(+thread+)+static+void*+_tls_ret;

static+void+__stdcall+saveret(void+*retaddr)+{
++++_tls_ret+=+retaddr;
}

static+void*+__stdcall+_getret()+{
++++return+_tls_ret;
}

__declspec(naked)
static+void+__stdcall+restret_and_return_int(int+retval)+{
++++__asm+{
++++++++call+_getret
++++++++mov+[esp],+eax+++;+/*+replace+current+retaddr+with+saved+*/
++++++++mov+eax,+[esp%2B4]+;+/*+retval+*/
++++++++ret+4
++++}
}

static+void+__stdcall+_dbg_printf_beg(const+char+*fmt,+va_list+args)+{
++++printf("calling+printf(\"%25s\")\n",+fmt);
}

static+void+__stdcall+_dbg_printf_end(int+ret)+{
++++printf("printf()+returned+%25d\n",+ret);
}

__declspec(naked)
int+dbg_printf(const+char+*fmt,+...)
{
++++static+const+void+*addr_printf+=+printf;
++++/*+prolog+*/
++++__asm+{
++++++++push+ebp
++++++++mov++ebp,+esp
++++++++sub++esp,+__LOCAL_SIZE
++++++++nop
++++}
++++{
++++++++va_list+args;
++++++++va_start(args,+fmt);
++++++++_dbg_printf_beg(fmt,+args);
++++++++va_end(args);
++++}
++++/*+epilog+*/
++++__asm+{
++++++++mov++esp,+ebp
++++++++pop++ebp
++++}
++++__asm++{
++++++++call+saveret
++++++++call+addr_printf
++++++++push+eax
++++++++push+eax
++++++++call+_dbg_printf_end
++++++++call+restret_and_return_int
++++}
}|code-block|syntax|javascript|111763|entityMap^0|K|7|0|G|G|Y|8|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Actually, there's a way to call a function that doesn’t have a <code>va_list</code> version from a wrapper. The idea is to use assembler, do not touch arguments on the stack, and temporarily replace the function return address.
An example for Visual C x86. <code>call addr_printf</code> calls <code>printf()</code>:
<pre><code>__declspec( thread ) static void* _tls_ret;

static void __stdcall saveret(void *retaddr) {
 _tls_ret = retaddr;
}

static void* __stdcall _getret() {
 return _tls_ret;
}

__declspec(naked)
static void __stdcall restret_and_return_int(int retval) {
 __asm {
 call _getret
 mov [esp], eax ; /* replace current retaddr with saved */
 mov eax, [esp+4] ; /* retval */
 ret 4
 }
}

static void __stdcall _dbg_printf_beg(const char *fmt, va_list args) {
 printf(&quot;calling printf(\&quot;%s\&quot;)\n&quot;, fmt);
}

static void __stdcall _dbg_printf_end(int ret) {
 printf(&quot;printf() returned %d\n&quot;, ret);
}

__declspec(naked)
int dbg_printf(const char *fmt, ...)
{
 static const void *addr_printf = printf;
 /* prolog */
 __asm {
 push ebp
 mov ebp, esp
 sub esp, __LOCAL_SIZE
 nop
 }
 {
 va_list args;
 va_start(args, fmt);
 _dbg_printf_beg(fmt, args);
 va_end(args);
 }
 /* epilog */
 __asm {
 mov esp, ebp
 pop ebp
 }
 __asm {
 call saveret
 call addr_printf
 push eax
 push eax
 call _dbg_printf_end
 call restret_and_return_int
 }
}
</code></pre>

I am looking to do this in C/C++. I came across <a href="http://www.swig.org/Doc1.3/Varargs.html" rel="nofollow noreferrer">Variable Length Arguments</a>, but this suggests a solution with Python and C using <a href="http://sourceware.org/libffi/" rel="nofollow noreferrer">libffi</a>.
Now, if I want to wrap the <code>printf</code> function with <code>myprintf</code>.
I do it like below:
<pre><code>void myprintf(char* fmt, ...)
{
 va_list args;
 va_start(args, fmt);
 printf(fmt, args);
 va_end(args);
}

int _tmain(int argc, _TCHAR* argv[])
{
 int a = 9;
 int b = 10;
 char v = 'C';
 myprintf(&quot;This is a number: %d and \nthis is a character: %c and \n another number: %d\n&quot;, a, v, b);
 return 0;
}
</code></pre>
But the results are not as expected!
<pre class="lang-none prettyprint-override"><code>This is a number: 1244780 and
this is a character: h and
another number: 29953463
</code></pre>
What did I miss?

How can I wrap a function with variable length arguments?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我希望在C/C++中实现这一点。我遇到了，但这表明了使用和C的解决方案。现在，如果我想用myprintf包装printf函数。我这样做如下：void myprintf(char* fmt, ...){    va_list args;    va_start(args, fmt);    printf(fmt, arg...

问如何用可变长度参数包装函数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何用可变长度参数包装函数？EN