原文地址:https://blog.csdn.net/jinkui2008/article/details/1967055

#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap)      ( ap = (va_list)0 )

va_list args;
           char buf[1024];
        .........
        va_start(args, msg);
        int len=_vsnprintf(buf+TIMEBUF_LENGTH, 1000, msg, args);
        va_end(args);

  va_list arg_ptr:定义一个指向个数可变的参数列表指针;
  
  va_start(arg_ptr, argN):使参数列表指针arg_ptr指向函数参数列表中的第一个可选参数,说明:argN是位于第一个可选参数之前的固定参数,(或者说,最后一个固定参数;…之前的一个参数),函数参数列表中参数在内存中的顺序与函数声明时的顺序是一致的。如果有一va函数的声明是void va_test(char a, char b, char c, …),则它的固定参数依次是a,b,c,最后一个固定参数argN为c,因此就是va_start(arg_ptr, c)。
  
  va_arg(arg_ptr, type):返回参数列表中指针arg_ptr所指的参数,返回类型为type,并使指针arg_ptr指向参数列表中下一个参数。
  
  va_copy(dest, src):dest,src的类型都是va_list,va_copy()用于复制参数列表指针,将dest初始化为src。
  
  va_end(arg_ptr):清空参数列表,并置参数指针arg_ptr无效。说明:指针arg_ptr被置无效后,可以通过调用 va_start()、va_copy()恢复arg_ptr。每次调用va_start() / va_copy()后,必须得有相应的va_end()与之匹配。参数指针可以在参数列表中随意地来回移动,但必须在va_start() … va_end()之内。
  
  
  
  ◎用法:
  func( Type para1, Type para2, Type para3, ... )
  {
   /****** Step 1 ******/
   va_list ap;
   va_start( ap, para3 ); //一定要“...”之前的那个参数
  
   /****** Step 2 ******/
   //此时ap指向第一个可变参数
   //调用va_arg取得里面的值
  
   Type xx = va_arg( ap, Type );
  
   //Type一定要相同,如:
   //char *p = va_arg( ap, char *);
   //int i = va_arg( ap, int );
  
   //如果有多个参数继续调用va_arg
  
   /****** Step 3 ******/
   va_end(ap); //For robust!
  }
  
  ◎研究:
  typedef char * va_list;
  
  #define va_start _crt_va_start
  #define va_arg _crt_va_arg
  #define va_end _crt_va_end
  
  #define _crt_va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
  #define _crt_va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
  #define _crt_va_end(ap) ( ap = (va_list)0 )
  va_list argptr;
  C语言的函数是从右向左压入堆栈的,调用va_start后,
  按定义的宏运算,_ADDRESSOF得到v所在的地址,然后这个
  地址加上v的大小,则使ap指向第一个可变参数如图:
  
   栈底 高地址
   | .......
   | 函数返回地址
   | .......
   | 函数最后一个参数
   | ....
   | 函数第一个可变参数 <--va_start后ap指向
   | 函数最后一个固定参数
   | 函数第一个固定参数
   栈顶 低地址
  
  
  然后,用va_arg()取得类型t的可变参数值, 先是让ap指向下一个参数:
  ap += _INTSIZEOF(t),然后在减去_INTSIZEOF(t),使得表达式结果为
  ap之前的值,即当前需要得到的参数的地址,强制转换成指向此参数的
  类型的指针,然后用*取值
  
  最后,用va_end(ap),给ap初始化,保持健壮性。
 
  一般的用法是这样(个人理解)
  va_list args; //声明变量
  va_start(args, fmt); //开始解析。args指向fmt后面的参数
  TYPE var = va_arg(args, TYPE); //取下一个参数并返回。args指向下一个参数
  va_end(args); //结束解析

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////

我想大概很多學C 的人第一個會用的的標準庫存函數是printf跟scanf ,
可是大家一定發現printf與scanf 的arguments 可以不定數量, 那如果自
己想寫, 該怎麼做呢? 在K&R 的課本的附錄B 其實可以找到答案, 我就整
理放到這邊來, 不過說實在話, 除了我自己沒有真的用過以外, 個人覺得
用到的機率也不高, 不過知道一下也不錯:

首先有關含數宣告部份:
  data_type func(int ap, ...)    以...表示不定引數數量,
需要使用的header file:
  stdarg.h
相關之macros (定義在stdarg.h):
  va_start, va_arg, va_end
說明
  1.首先在函數中宣告一型別為va_list 之variable, 如:
    va_list ap;
  2.然後在要取得沒有參數名稱與之對應的arguments 前先呼叫va_start, 如:
    va_start (va_list, lastarg);
  3.再呼叫va_arg便可以依次取得各 (無參數名對應) 引數, 如:
    type va_arg (va_list, type);
  4.最後呼叫va_end結束, 如:
    void va_end (va_list ap);
各定義與使用參閱所使用之C Compiler的手冊, 以下之stdarg.h取自FreeBSD 4.8,
請參考.

/*-
 * Copyright (c) 1991, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      @(#)stdarg.h    8.1 (Berkeley) 6/10/93
 * $FreeBSD: src/sys/i386/include/stdarg.h,v 1.10 1999/08/28 00:44:26 peter Exp$
 */

#ifndef _STDARG_H_
#define _STDARG_H_

typedef char *va_list;

#define __va_size(type) /
        (((sizeof(type) + sizeof(int) - 1) / sizeof(int)) * sizeof(int))

#ifdef __GNUC__
#define va_start(ap, last) /
        ((ap) = (va_list)__builtin_next_arg(last))
#else
#define va_start(ap, last) /
        ((ap) = (va_list)&(last) + __va_size(last))
#endif

#define va_arg(ap, type) /
        (*(type *)((ap) += __va_size(type), (ap) - __va_size(type)))

#define va_end(ap)

#endif /* !_STDARG_H_ */
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
宏--不定参数
(zz from 88, 原作者IceVolcano,还没看完,先rob过来:)

在实现不定参数函数的时候,要用到va_size,va_start,va_arg三个宏。
在stdarg.h里有对这三个宏的实现。
此头文件如下,略去了开头的一大段注释:
#ifndef _MACHINE_STDARG_H_
#define _MACHINE_STDARG_H_
#include <sys/cdefs.h>
#include <sys/_types.h>
#ifndef _VA_LIST_DECLARED
#define _VA_LIST_DECLARED
typedef __va_list   va_list;
#endif
#if (defined(__GNUC__) && (__GNUC__ == 2 && __GNUC_MINOR__ > 95 || __GNUC__ >=
3) && !defined(__INTEL_COMPILER))
#define va_start(ap, last) /
    __builtin_stdarg_start((ap), (last))
#define va_arg(ap, type) /
    __builtin_va_arg((ap), type)
#if __ISO_C_VISIBLE >= 1999
#define va_copy(dest, src) /
    __builtin_va_copy((dest), (src))
#endif
#define va_end(ap) /
    __builtin_va_end(ap)
#else   /* ! (__GNUC__ post GCC 2.95 || __INTEL_COMPILER) */
#define __va_size(type) /
    (((sizeof(type) + sizeof(int) - 1) / sizeof(int)) * sizeof(int))
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
#define va_start(ap, last) /
    ((ap) = (va_list)__builtin_next_arg(last))
#else   /* non-GNU compiler */
#define va_start(ap, last) /
    ((ap) = (va_list)&(last) + __va_size(last))
#endif  /* __GNUC__ */
#define va_arg(ap, type) /
    (*(type *)((ap) += __va_size(type), (ap) - __va_size(type)))
#if __ISO_C_VISIBLE >= 1999
#define va_copy(dest, src) /
    ((dest) = (src))
#endif
#define va_end(ap)
#endif /* __GNUC__ post GCC 2.95 */
#endif /* !_MACHINE_STDARG_H_ */

开始是一些基本的头文件保护和一些基本的define宏,以备后用,跳过。
然后碰到一个小兵:va_list。
va_list是__va_list,追根揭底是char *,已解决(小兵就是小兵,唉)。
然后关注三个关键宏va_size,va_start,va_arg,三元猛将。
然而进一步考察发现,他们是双胞胎,根据是否用gcc决定是哥哥还是弟弟出征。
先考虑不用gcc的情况,暂且称之为哥哥。
第一个宏__va_size:
#define __va_size(type) /
        (((sizeof(type) + sizeof(int) - 1) / sizeof(int)) * sizeof(int))
这个宏并不在“应用层”(套用一下tcp/ip的说法)出现,我们用不定参数的时候并不会接
触到这个宏。他是为了另外两个存在的。确切的说,他是秘书。但我们还得了解它,不然编
译器会报错,实际运行会core dump。
咋一眼看来,是一个关于类型大小的映射。
映射结果如下:
1   4
2   4
3   4
4   4
5   8
6   8
7   8
8   8
9   12
10  12
11  12
12  12
.   .
.   .
.   .
看起来像“对齐”。估计这就是做这样映射的原因。具体情况待下面给出示例代码后再说。
第二个宏va_start:
#define va_start(ap, last) /
        ((ap) = (va_list)&(last) + __va_size(last))
可见,他是跳过last段,让栈指针指向下一个参数地址。
这里无端端的以跳过一个参数号称start,是不是犯傻?给出示例代码后再说。
刚刚开始就扔下两个问题,搞得人心里痒痒,确有不负责任之嫌。但其实,我写这个东西也
蛮头疼的,我知道看的人也很不爽,说实话如果我看也很不爽,总是有个疙瘩在心里,不免
心里会骂作者,“死没良心的,居然调人胃口,好,老子看你有何能耐”。
上面两个问题的完全解答依赖对示例代码的分析,而对示例代码的分析依赖于对va_start的
分析,所以这里只好先提出这么一个问题。因为不提的话,后来的对示例代码的分析会放松
对va_start的警戒,以为没什么名堂,可有可无,或者机械的套用。
其实很多书都这样,开头写的东西不能太深入,因为只有说道后面的知识才能深入下去,而
后面的知识是在前面的知识的基础上。这样只能靠读者去反复阅读,其意自显。而且有的书
,在我细读前一两章的东西后,再看后面,居然发现自己已经得出了结论。这说明整个书所
述的知识是一个
体系,相互依赖。而好的书,在于作者能够把握这个体系,能够把整个知识当作一个网络来
讲述……
唉!说着说着就入了无数个栈,还好我是学过的,自认对栈的管理还是可以,现在就退栈,
接着第三个宏。

第三个宏va_arg:
#define va_arg(ap, type) /
        (*(type *)((ap) += __va_size(type), (ap) - __va_size(type)))
这个宏有三个部分,他做了2件事
1、返回为type所标明的类型的值,就是取值。
   如:int i = va_arg(format, int);
2、让栈指针移到下一个参数的头位置。
三个部分的解释:
*(type *):返回为type所标明的类型的值,非地址。
(ap) += __va_size(type):ap移到后一个参数。
(ap) - __va_size(type):给出此宏所取的参数的地址。
这里,用了一个逗号句法,实现移动栈指针和返回参数地址。
哥哥被考察完了,用它来实现点东西,示例代码如下:
#undef __GNUC__
#include <stdio.h>
#include <stdarg.h>
//#define GOINT
void func(char * list, ...)
{
    va_list l;
    int i;
    char c;
    printf("list:     0x%08x/n", &list);
    va_start(l,list);
    printf("va_start: 0x%08x/n", l);
#ifdef GOINT
    i = va_arg(l, int);
    printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
    i = va_arg(l, int);
    printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
    i = va_arg(l, int);
    printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
    i = va_arg(l, int);
    printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
#else
    c = va_arg(l, char);
    printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
    c = va_arg(l, char);
    printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
    c = va_arg(l, char);
    printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
    c = va_arg(l, char);
    printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
#endif
}
int main(void)
{
    int i = 1;
    char c = 'a';
#ifdef GOINT
    func("ABCDEF",i,i,i,i);
#else
    func("ABCDEF",c,c,c,c);
#endif
    printf("%d/n", sizeof("ABCDEF"));
    return 0;
}
 
这里有几点值得关注:
1、第一行的#undef __GNUC__是被逼的
   否则就会依照gnu c complier的方法把__builtin_xxx编进去
2、#define GOINT的结果:
   list:     0xbfbfecd0
   va_start: 0xbfbfecd4
   va_arg:   0xbfbfecd8 - 1
   va_arg:   0xbfbfecdc - 1
   va_arg:   0xbfbfece0 - 1
   va_arg:   0xbfbfece4 - 1
   没有#define GOINT的结果:
   list:     0xbfbfecd0
   va_start: 0xbfbfecd4
   va_arg:   0xbfbfecd8 - a
   va_arg:   0xbfbfecdc - a
   va_arg:   0xbfbfece0 - a
   va_arg:   0xbfbfece4 - a
   两者一样,char和int在栈里的所占空间一样大。
   这可以解释为什么要提供一个va_size而不直接用sizeof。
   看来“对齐”是无处不在。
栈结构如下:
#define GOINT的结果:
|d0    |d4    |d8    |dc    |e0    |
+------+------+------+------+------+
|char *|     1|     1|     1|     1|
+------+------+------+------+------+
|4bytes|4bytes|4bytes|4bytes|4bytes|
没有#define GOINT的结果:
|d0    |d4    |d8    |dc    |e0    |
+------+------+------+------+------+
|char *|     1|     1|     1|     1|
+------+------+------+------+------+
|4bytes|4bytes|4bytes|4bytes|4bytes|
其中char *指向ABCDEF/n在内存里的位置,所以,如下的话:
printf("l=list:   0x%08x/n", l);
打印出:
l=list:     0x0804875c
这里有一点,C的进栈是从右到左,也就是说char *至最后进入的。
结合第1、2个宏,可以看出,为了使栈内参数顺序和数据位存放顺序一致,栈向小的那个方
向增长,最后指向最小的那个位置。

代码流程大致如下:
1、用va_start得到栈“开头”地址,开头打引号。
   因为牺牲了第一个参数。
2、用va_arg得到设计的变量类型的值,即传入的形参值。
3、重复2,直至所有参数取完。
实际应用中第3步由传入函数的一个参数保证,以printf为例,他的第一个参数是字符串。
函数在得到这个字符串后,对之分析,提取%d%x等。可见,第一个参数一般担当决定参数个
数和类型的任务。
但是这个任务是由程序员控制的,所以这里就可以做点文章。喜欢搞鬼的家伙们就爱这些由
程序员实际控制的代码。他绕过了编译器,或者说利用了编译器,或者说玩了一把编译器,
结果得到了一个不受束缚的指针,一般就会忍不住指向root shell。

接下来理应分析弟弟了,可是,上面说到的#undef __GNUC__让我想各位致歉。近期我没能
力也没太有时间和兴趣深入研究gcc。就算man以下,也是搜索字符串看重点。
起先我的示例代码里并没有#undef __GNUC__。用gcc -E main.c | less一看,结果是
 i = __builtin_va_arg((l), int);
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
 i = __builtin_va_arg((l), int);
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
 i = __builtin_va_arg((l), int);
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
 i = __builtin_va_arg((l), int);
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
预编译器并没有解释 __builtin_va_arg,我想到一定是定义了__GNUC__。于是加上#undef
__GNUC__,结果对了
 i = (*(int *)((l) += (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int)), (l) - (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int))));
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
 i = (*(int *)((l) += (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int)), (l) - (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int))));
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
 i = (*(int *)((l) += (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int)), (l) - (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int))));
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
 i = (*(int *)((l) += (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int)), (l) - (((sizeof(int) + sizeof(int) - 1) / sizeof(int)) *
sizeof(int))));
 printf("va_arg:   0x%08x", l); printf(" - %d/n", i);
而且#undef __GNUC__要加在第一行,看起来是gcc默认了__GNUC__。如果-E后的结果不再预
处理,直接送入编译器,那么看起来是编译器认识__builtin_xxx了,就没有头文件可以看
了。没办法,i服了u。
不过这里倒是引出一个问题。
我先写的示例代码是没有#undef __GNUC__,也就是以__builtin_xxx编译的。这个时候
c = va_arg(l, char);
printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
c = va_arg(l, char);
printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
c = va_arg(l, char);
printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
c = va_arg(l, char);
printf("va_arg:   0x%08x", l); printf(" - %c/n", c);
这个段是warning的,(既然是编译器给出的warning,似乎是由编译器解释__builtin_xxx
了)
main.c: In function `func':
main.c:24: warning: `char' is promoted to `int' when passed through `...'
main.c:24: warning: (so you should pass `int' not `char' to `va_arg')
main.c:24: note: if this code is reached, the program will abort
main.c:26: warning: `char' is promoted to `int' when passed through `...'
main.c:26: note: if this code is reached, the program will abort
main.c:28: warning: `char' is promoted to `int' when passed through `...'
main.c:28: note: if this code is reached, the program will abort
main.c:30: warning: `char' is promoted to `int' when passed through `...'
main.c:30: note: if this code is reached, the program will abort
实际的运行也导致了core dump,即使是配合func("ABCDEF",i,i,i,i);的传入,也照样
dump。

这里对QuoVadis的帖子再作分析,他的给出代码如下:
float Test(float first,...)
{
    float sum = 0, i = first;
    va_list marker;
    va_start(marker, first);
    for (int j = 0; j < 3; ++j)
    {
        sum += i;
        i = va_arg(marker, float);
    }
    va_end( marker );
    return sum;
}
float x = Test(1.0, 2.0, 3.0);
不出我所料
main.c: In function `Test':
main.c:42: error: 'for' loop initial declaration used outside C99 mode
main.c:45: warning: `float' is promoted to `double' when passed through `...'
main.c:45: warning: (so you should pass `double' not `float' to `va_arg')
main.c:45: note: if this code is reached, the program will abort
*** Error code 1
Stop in /home/ycheng/programs/c.
修改关于j,编译通过,但是运行dump。
加上#undef __GNUC__,编译ok
#undef __GNUC__
#include <stdio.h>
#include <stdarg.h>
float Test(float first,...)
{
    float sum = 0, i = first;
    int j;
    va_list marker;
    va_start(marker, first);
    for(j = 0; j < 3; ++j)
    {
        sum += i;
        i = va_arg(marker, float);
    }
    va_end(marker);
    return sum;
}
int main(void)
{
    float x = Test(1.0, 2.0, 3.0);
    printf("%f/n", x);
    return 0;
}
运行结果3.000000。
原因显然是1.0, 2.0, 3.0默认是double所致。
但还有一个问题,就是i = first一句。
我看了好久,i的值在for循环里的i = va_arg(marker, float);后分别是0 2 0,怎么会出
来3?
原因就在这一句,在sum += i;的配合下,sum的值在整个过程里分别为
0   //float sum = 0
1   //1st for(), i = first; sum += 1;
1   //2nd for(), sum += 0
3   //3rd for(), sum += 2
|  4bytes   |  4bytes   |  4bytes   |  4bytes   |  4bytes   |
+-----------+-----------+-----------+-----------+-----------+
|00|00|80|3F|00|00|00|00|00|00|00|40|00|00|00|00|00|00|80|40|
+-----------+-----------+-----------+-----------+-----------+
|   1.0f    |          2.0          |           3.0         |
 ^
 |
栈指针
这里左面地址小右面大,结合进栈顺序,3.0 2.0 1.0f的进站顺序为3.0->2.0->1.0f。
3.0先进,占据最高8bytes,然后2.0,再8bytes,最后1.0f,只有4bytes。栈指针指向1.0
的最低位
这个很要紧,关系到va_arg(marker, float);取哪4个bytes
结合代码:
float sum = 0, i = first;
//sum=0, i=1,这个1是由于类型转换,根栈里数据存关系不大,有还是有的
int j;
va_list marker;
va_start(marker, first);
//marker跳过了开始的4bytes,也就是跳过了1.0f
{
    sum += i;
    //sum+=1 sum=1
    i = va_arg(marker, float);
    //取出2.0的高4位当成float,结果是0,marker走
}
{
    sum += i;
    //sum+=2 sum=3
    i = va_arg(marker, float);
    //取出2.0的低4位当成float,结果是2,marker走
}
{
    sum += i;
    //sum+=0 sum=3
    i = va_arg(marker, float);
    //取出3.0的高4位当成float,结果是0,marker走
}
va_end(marker);
return sum;
//不用再说了
由此还可得一点,第一个参数虽然是double,但是函数声明里是float。
C里的栈是归调用者管的,这里是main管理到底给Test什么东西,多大的空间。
由于Test的声明里有float first,main还是能认出来。
所以main在这里把1.0降成1.0f入栈,first是一个的的确确的4bytes的float。
而此后,main实在无力知晓了,只能把double入栈,这也非main的错。
还有一个问题,就是addplus提出来的。
无论是float还是double,入栈的均为8bytes的double。
我试了一下还真的有这回事,再试了一下printf("%f %f", 1.0f, 2.0);
真能正确的打印出来。
看来这里还有名堂,这涉及编译器对类型的做法,只能在写不定参数函数的时候自己多试试
了。
 
宏是简单的,简单到会出错;
指针是复杂的,复杂到会出错。
这就是C
---------------------
作者:jinkui2008
来源:CSDN
原文:https://blog.csdn.net/jinkui2008/article/details/1967055
版权声明:本文为博主原创文章,转载请附上博文链接!

(转)用库函数stdarg.h实现函数参数的可变的更多相关文章

  1. 使用stdarg.h实现可变长度参数

    现在先用一个使用过程讲解一下: ◎用法: func( Type para1, Type para2, Type para3, … ) { /****** Step 1 ******/ va_list ...

  2. Python python 函数参数:可变参数

    # 可变参数 '''传入的参数数量是不确定的 ''' '''若是要计算几个数(未知)的平方和 ''' def cal(nums): sum = 0 for num in nums: sum = sum ...

  3. #include&lt;stdarg.h&gt; 可变参数使用

    今天上计算方法这课时觉得无聊至极,于是拿出C++编程之道来看了看..无意之中看到了#include<stdarg.h> va_list,va_start,va_end等东西,不知是怎么用的 ...

  4. stdarg.h详解

    读Linux内核中的vsprintf函数的时候遇到了C语言的可变参数调用,查了挺多资料还是这篇比较详细,而且自己验证了下,确实如此 (一)写一个简单的可变参数的C函数  下面我们来探讨如何写一个简单的 ...

  5. C语言 函数参数不确定时 需要用到va_start和va_end函数

    1.在C中,当我们无法列出传递函数的所有实参的类型和数目时,可以用省略号指定参数表 void foo(...);void foo(parm_list,...); 这种方式和我们以前认识的不大一样,但我 ...

  6. 可变参数函数(stdarg.h)的使用

    2013/5/3记录: stdarg.h是C语言中C标准函数库的头文件,stdarg是由standard(标准) arguments(参数)简化而来,主要目的为让函数能够接收可变参数.   stdar ...

  7. 第 16 章 C 预处理器和 C 库(可变参数:stdarg.h)

    /*------------------------------------------------- varargs.c -- use variable number of arguments -- ...

  8. #include &lt;stdarg.h&gt;

    名称描述相容  // 作用描述 va_start使va_list指向起始的参数 va_arg检索参数C89 va_end释放va_list va_copy拷贝va_list的内容 实例解析: #inc ...

  9. 《C标准库》——之&lt;stdarg.h&gt;

    C语言有个很强大的功能,依靠它,实现了printf等这类有着变长参数列表的函数或者宏.它就是在<stdarg.h>里的变长参数. 内容: va_list :它是一个适合保存va_start ...

随机推荐

  1. 文件IO操作

    前言 本文介绍使用java进行简单的文件IO操作. 操作步骤 - 读文件 1. 定义一个Scanner对象 2. 调用该对象的input函数族进行文件读取 (参见下面代码) 3. 关闭输入流 说明:其 ...

  2. Eclipse 整合cvs教程及遇到的问题

    今天看着视频教程学习cvs版本管理,现在很多企业开发或许都采用了版本管理器,因为这样可以更好的进行团退开发与代码管理,所以学习一种版本管理技术还是很重要的. 最原始的独立版本管理是由两部分组成的,一个 ...

  3. java方法:flush()

    flush本意是冲刷,这个方法大概取自它引申义冲马桶的意思,马桶有个池子,你往里面扔东西,会暂时保存在池子里,只有你放水冲下去,东西才会进入下水道. 同理很多流都有一个这样的池子,专业术语叫缓冲区,当 ...

  4. 转载_2012年的Android之旅:梦想、学习、坚持、自信、淡定

    原文地址:http://blog.csdn.net/luoshengyang/article/details/8452527 2012年的Android之旅:梦想.学习.坚持.自信.淡定.. ---- ...

  5. 201521123114 《Java程序设计》第10周学习总结

    1. 本章学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结异常与多线程相关内容. 1. 创建线程方式: 定义Thread的子类 定义实现Runnable接口的类,实现run() 2. 调用s ...

  6. mysql主键,外键,索引

    主键 唯一而非空,只能有一个 作用: 1.唯一的标识一行  2.作为一个可以被外键有效引用的对象  3.保证数据完整性 设计原则: 1. 主键应当是对用户没有意义的.如果用户看到了一个表示多对多关系的 ...

  7. HTML CSS JavaScript 工作笔记

    1. onclick方法如何传递多个参数 "<a href='#' onclick=\"applied_status('" + ids + "', '&q ...

  8. Swing中支持自动换行的WrapLayout

    http://www.cnblogs.com/TLightSky/p/3482454.html ———————————————————————————————————————————————————— ...

  9. python基础-PyYaml操作yaml文件

    yaml语法 格式 它的基本语法规则如下 大小写敏感 使用缩进表示层级关系 缩进时不允许使用Tab键,只允许使用空格. 缩进的空格数目不重要,只要相同层级的元素左侧对齐即可 YAML 支持的数据结构有 ...

  10. Linux 系统及编程相关知识总汇

    Linux  C function() 参考手册 STL 学习文档 Linux内核