c语言中可变参数函数的设计

时间:2022-07-03 09:11:32

C语言中可变参数函数的设计

分类: C/C++ 2144人阅读 评论(0) 收藏 举报

http://blog.csdn.net/oathevil/article/details/6436223

c语言中可变参数函数的设计
        ----- 最近想好好学学这个, 先把网上搜集得资料贴上. 


================================================================================
================================================================================
================================================================================

 参数可变函数的实现(上)    CSDN Blog推出文章指数概念,文章指数是对Blog文章综合评分后推算出的,综合评分项分别是该文章的点击量,回复次数,被网摘收录数量,文章长度和文章类型;满分100,每月更新一次。

 此文献给如我一般还在探索C语言之路的朋友们。

 

注:本文中测试程序的编译环境为win2000和VC6.0

缘起:

作为一个程序员,我没有写过参数可变的函数,我相信大部分朋友也没有涉及过,或者我的境界层次太低了。那么缘何我要去揭这一层面纱呢?因为好奇!

我是个思维具有极大惰性的人,曾经识得参数可变函数,也懒得去深究,但是它的三点(函数声明时参数列表中的“…”)却深刻的映入了我的记忆里,而且是带着若干个闪耀的问号。可是就在昨天,在拜读某君的高论时,它再一次出现了。我的资质真的是不太够,因为某君在谈到它时只是给出了<stdarg.h>中关于它的宏定义,我想大概在高手眼里,点这一下就神会了吧。可是他这么轻轻一点却使留在记忆里曾经的那几个问号无限的膨胀,以至于我这个又菜又懒的所谓程序员也萌生了莫大的好奇。

 

破题:

   但凡所谓“实现”都是从没有到有的过程,但是我只是想去解惑它的实现,因为它原本就是好端端的正为成千上万的程序员们服务。

   还是从我们熟悉的printf说起:

   如果你是个C语言的程序员,无论你是初学者还是高高手,对于printf都不会陌生,甚至你已经用了无数次了。我已经说过我是个有极大惰性的人,所以每次用printf都是照本宣科,规规矩矩的按教科书上说的做,从来没有问过一个为什么,这就是所谓的“熟视无睹”吧。

其实,printf函数是一个典型的参数可变的函数。在保证它的第一个参数是字符串的条件下,你可以输任意数量任意合法类型的参数。只要你在第一个字符串参数中使用了对应的格式化字符串,你就可以输出正确的值。这难道不是件很有趣的事吗?那它是怎么做到的?

1,首先,怎么得到参数的值。对于一般的函数,我们可以通过参数对应在参数列表里的标识符来得到。但是参数可变函数那些可变的参数是没有参数标识符的,它只有“…”,所以通过标识符来得到是不可能的,我们只有另辟途径。

我们知道函数调用时都会分配栈空间,而函数调用机制中的栈结构如下图所示:

                       |     ......     |

                       ------------------

                       |     参数2      |

                       ------------------

                       |     参数1      |

                       ------------------

                       |    返回地址    |

                       ------------------

                       |调用函数运行状态|

                       ------------------

可见,参数是连续存储在栈里面的,那么也就是说,我们只要得到可变参数的前一个参数的地址,就可以通过指针访问到那些可变参数。但是怎么样得到可变参数的前一个参数的地址呢?不知道你注意到没有,参数可变函数在可变参数之前必有一个参数是固定的,并使用标识符,而且通常被声明为char*类型,printf函数也不例外。这样的话,我们就可以通过这个参数对应的标识符来得到地址,从而访问其他参数变得可能。我们可以写一个测试程序来试一下:

#include <stdio.h>

 

void va_test(char* fmt,...);//参数可变的函数声明

 

void main()

{

    int a=1,c=55;

       char b='b';

    va_test("",a,b,c);//用四个参数做测试

}

 

void va_test(char* fmt,...) //参数可变的函数定义,注意第一个参数为char* fmt

{

   char *p=NULL;

 

      p=(char *)&fmt;//注意不是指向fmt,而是指向&fmt,并且强制转化为char *,以便一个一个字节访问

      for(int i = 0;i<16;i++)//16是通过计算的值(参数个数*4个字节),只是为了测试,暂且将就一下

      {

                printf("%.4d ",*p);//输出p指针指向地址的值

        p++;

      }

}

 

编译运行的结果为

  0056 0000 0066 0000 | 0001 0000 0000 0000 | 0098 0000 0000 0000 | 0055 0000 0000 0000

 

由运行结果可见,通过这样方式可以逐一获得可变参数的值。

至于为什么通常被声明为char*类型,我们慢慢看来。

2,怎样确定参数类型和数量

通过上述的方式,我们首先解决了取得可变参数值的问题,但是对于一个参数,值很重要,其类型同样举足轻重,而对于一个函数来讲参数个数也非常重要,否则就会产生了一系列的麻烦来。通过访问存储参数的栈空间,我们并不能得到关于类型的任何信息和参数个数的任何信息。我想你应该想到了——使用char *参数。Printf函数就是这样实现的,它把后面的可变参数类型都放到了char *指向的字符数组里,并通过%来标识以便与其它的字符相区别,从而确定了参数类型也确定了参数个数。其实,用何种方式来到达这样的效果取决于函数的实现。比如说,定义一个函数,预知它的可变参数类型都是int,那么固定参数完全可以用int类型来替换char*类型,因为只要得到参数个数就可以了。

3,言归正传

   我想到了这里,大概的轮廓已经呈现出来了。本来想就此作罢的(我的惰性使然),但是一想到如果不具实用性便可能是一堆废物,枉费我打了这么些字,决定还是继续下去。

   我是比较抵制用那些不明所以的宏定义的,所以在上面的阐述里一点都没有涉及定义在<stdarg.h>的va(variable-argument)宏。事实上,当时让我产生极大疑惑和好奇的正是这几个宏定义。但是现在我们不得不要去和这些宏定义打打交道,毕竟我们在讨生计的时候还得用上他们,这也是我曰之为“言归正传”的理由。

   好了,我们来看一下那些宏定义。

   打开<stdarg.h>文件,找一下va_*的宏定义,发现不单单只有一组,但是在各组定义前都会有宏编译。宏编译指示的是不同硬件平台和编译器下用怎样的va宏定义。比较一下,不同之处主要在偏移量的计算上。我们还是拿个典型又熟悉的——X86的相关宏定义:

1)typedef char * va_list;

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

 

3)#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )

4)#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

5)#define va_end(ap)      ( ap = (va_list)0 )

 

我们逐一看来:

第一个我想不必说了,类型定义罢了。第二个是颇有些来头的,我们也不得不搞懂它,因为后面的两个关键的宏定义都用到了。不知道你够不够细心,有没有发现在上面的测试程序中,第二个可变参数明明是char类型,可是在输出结果中占了4个byte。难道所有的参数都会占4个byte的空间?那如果是double类型的参数,且不是会丢失数据!如果你不嫌麻烦的话,再去做个测试吧,在上面的测试程序中用一个double类型(长度为8byte)和一个long double类型(长度为10byte)做可变参数。发现什么?double类型占了8byte,而long double占了12byte。好像都是4的整数倍哦。不得不引出另一个概念了“对齐(alignment)”,所谓对齐,对Intel80x86 机器来说就是要求每个变量的地址都是sizeof(int)的倍数。原来我们搞错了,char类型的参数只占了1byte,但是它后面的参数因为对齐的关系只能跳过3byte存储,而那3byte也就浪费掉了。那为什么要对齐?因为在对齐方式下,CPU 的运行效率要快得多(举个例子吧,要说明的是下面的例子是我从网上摘录下来的,不记得出处了。

示例:如下图,当一个long 型数(如图中long1)在内存中的位置正好与内存的字边界对齐时,CPU 存取这个数只需访问一次内存,而当一个long 型数(如图中的long2)在内存中的位置跨越了字边界时,CPU 存取这个数就需要多次访问内存,如i960cx 访问这样的数需读内存三次(一个BYTE、一个SHORT、一个BYTE,由CPU 的微代码执行,对软件透明),所以对齐方式下CPU 的运行效率明显快多了。

1       8       16      24      32   

------- ------- ------- ---------

| long1 | long1 | long1 | long1 |

------- ------- ------- ---------

|        |        |         | long2 |

------- ------- ------- ---------

| long2 | long2 | long2 |        |

------- ------- ------- ---------

| ....)。好像扯得有点远来,但是有助于对_INTSIZEOF(n)的理解。位操作对于我来说是玄的东东。单个位运算还应付得来,而这样一个表达式摆在面前就晕了。怎么办?菜鸟自有菜的办法。(待续)


Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=14721

---------------------------------------------------------------------------------------------------------------------

 C语言中的可变参数函数    CSDN Blog推出文章指数概念,文章指数是对Blog文章综合评分后推算出的,综合评分项分别是该文章的点击量,回复次数,被网摘收录数量,文章长度和文章类型;满分100,每月更新一次。

第一篇

C语言编程中有时会遇到一些参数个数可变的函数,例如printf()函数,其函数原型为:

int printf( const char* format, ...);

它除了有一个参数format固定以外,后面跟的参数的个数和类型是可变的(用三个点“…”做参数占位符),实际调用时可以有以下的形式:

printf("%d",i);
printf("%s",s);
printf("the number is %d ,string is:%s", i, s);   

一个简单的可变参数的C函数

     先看例子程序。该函数至少有一个整数参数,其后占位符…,表示后面参数的个数不定。在这个例子里,所有的输入参数必须都是整数,函数的功能只是打印所有参数的值。函数代码如下:

//示例代码1:可变参数函数的使用
#include "stdio.h"
#include "stdarg.h"
void simple_va_fun(int start, ...)
{
    va_list arg_ptr;
    int nArgValue =start;
    int nArgCout="0";  //可变参数的数目
    va_start(arg_ptr,start);  //以固定参数的地址为起点确定变参的内存起始地址。
    do
    {
        ++nArgCout;
        printf("the %d th arg: %d",nArgCout,nArgValue); //输出各参数的值
        nArgValue = va_arg(arg_ptr,int);  //得到下一个可变参数的值
    } while(nArgValue != -1);               
    return;
}
int main(int argc, char* argv[])
{
    simple_va_fun(100,-1);
    simple_va_fun(100,200,-1);
    return 0;
}

下面解释一下这些代码。从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:

⑴由于在程序中将用到以下这些宏:
void va_start( va_list arg_ptr, prev_param );
type va_arg( va_list arg_ptr, type );
void va_end( va_list arg_ptr );
va在这里是variable-argument(可变参数)的意思。
这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个头文件。

⑵函数里首先定义一个va_list型的变量,这里是arg_ptr,这个变量是存储参数地址的指针.因为得到参数的地址之后,再结合参数的类型,才能得到参数的值。

⑶然后用va_start宏初始化⑵中定义的变量arg_ptr,这个宏的第二个参数是可变参数列表的前一个参数,即最后一个固定参数。

⑷然后依次用va_arg宏使arg_ptr返回可变参数的地址,得到这个地址之后,结合参数的类型,就可以得到参数的值。

⑸设定结束条件,这里的条件就是判断参数值是否为-1。注意被调的函数在调用时是不知道可变参数的正确数目的,程序员必须自己在代码中指明结束条件。至于为什么它不会知道参数的数目,在看完这几个宏的内部实现机制后,自然就会明白。

第二篇

C语言之可变参数问题

 

C语言中有一种长度不确定的参数,形如:"…",它主要用在参数个数不确定的函数中,我们最容易想到的例子是printf函数。

  原型:

  int printf( const char *format [, argument]... );

  使用例:

  printf("Enjoy yourself everyday!/n");

  printf("The value is %d!/n", value);

  这种可变参数可以说是C语言一个比较难理解的部分,这里会由几个问题引发一些对它的分析。

  注意:在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任意数量的函数参数。

  问题:printf的实现

  请问,如何自己实现printf函数,如何处理其中的可变参数问题? 答案与分析:

  在标准C语言中定义了一个头文件专门用来对付可变参数列表,它包含了一组宏,和一个va_list的typedef声明。一个典型实现如下:

  typedef char* va_list;

  #define va_start(list) list = (char*)&va_alist

  #define va_end(list)

  #define va_arg(list, mode)/

  ((mode*) (list += sizeof(mode)))[-1]

  自己实现printf:

  #include

  int printf(char* format, …)

  {

  va_list ap;

  va_start(ap, format);

  int n = vprintf(format, ap);

  va_end(ap);

  return n;

  }

  问题:运行时才确定的参数

  有没有办法写一个函数,这个函数参数的具体形式可以在运行时才确定?

  答案与分析:

  目前没有"正规"的解决办法,不过独门偏方倒是有一个,因为有一个函数已经给我们做出了这方面的榜样,那就是main(),它的原型是:

  int main(int argc,char *argv[]);
函数的参数是argc和argv。

  深入想一下,"只能在运行时确定参数形式",也就是说你没办法从声明中看到所接受的参数,也即是参数根本就没有固定的形式。常用的办法是你可以通过定义一个void *类型的参数,用它来指向实际的参数区,然后在函数中根据根据需要任意解释它们的含义。这就是main函数中argv的含义,而argc,则用来表明实际的参数个数,这为我们使用提供了进一步的方便,当然,这个参数不是必需的。

  虽然参数没有固定形式,但我们必然要在函数中解析参数的意义,因此,理所当然会有一个要求,就是调用者和被调者之间要对参数区内容的格式,大小,有效性等所有方面达成一致,否则南辕北辙各说各话就惨了。

  问题:可变长参数的传递

  有时候,需要编写一个函数,将它的可变长参数直接传递给另外的函数,请问,这个要求能否实现?

  答案与分析:

  目前,你尚无办法直接做到这一点,但是我们可以迂回前进,首先,我们定义被调用函数的参数为va_list类型,同时在调用函数中将可变长参数列表转换为va_list,这样就可以进行变长参数的传递了。看如下所示:

  void subfunc (char *fmt, va_list argp)

  {

  ...

  arg = va_arg (fmt, argp); /* 从argp中逐一取出所要的参数 */

  ...

  }

  void mainfunc (char *fmt, ...)

  {

  va_list argp;

  va_start (argp, fmt); /* 将可变长参数转换为va_list */

  subfunc (fmt, argp); /* 将va_list传递给子函数 */

  va_end (argp);

  ...

  }

  问题:可变长参数中类型为函数指针

  我想使用va_arg来提取出可变长参数中类型为函数指针的参数,结果却总是不正确,为什么?

  答案与分析:

  这个与va_arg的实现有关。一个简单的、演示版的va_arg实现如下:

  #define va_arg(argp, type) /

  (*(type *)(((argp) += sizeof(type)) - sizeof(type)))

  其中,argp的类型是char *。

  如果你想用va_arg从可变参数列表中提取出函数指针类型的参数,例如

  int (*)(),则va_arg(argp, int (*)())被扩展为:

  (*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))

  显然,(int (*)() *)是无意义的。

  解决这个问题的办法是将函数指针用typedef定义成一个独立的数据类型,例如:

  typedef int (*funcptr)();

  这时候再调用va_arg(argp, funcptr)将被扩展为:

  (* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))

  这样就可以通过编译检查了。

  问题:可变长参数的获取

  有这样一个具有可变长参数的函数,其中有下列代码用来获取类型为float的实参:

  va_arg (argp, float);

  这样做可以吗?

  答案与分析:

  不可以。在可变长参数中,应用的是"加宽"原则。也就是float类型被扩展成double;char, short被扩展成int。因此,如果你要去可变长参数列表中原来为float类型的参数,需要用va_arg(argp, double)。对char和short类型的则用va_arg(argp, int)。

  问题:定义可变长参数的一个限制

  为什么我的编译器不允许我定义如下的函数,也就是可变长参数,但是没有任何的固定参数?

  int f (...)

  {

  ...

  }

  答案与分析:

  不可以。这是ANSI C 所要求的,你至少得定义一个固定参数。

  这个参数将被传递给va_start(),然后用va_arg()和va_end()来确定所有实际调用时可变长参数的类型和值。

第一篇

C语言编程中有时会遇到一些参数个数可变的函数,例如printf()函数,其函数原型为:

int printf( const char* format, ...);

它除了有一个参数format固定以外,后面跟的参数的个数和类型是可变的(用三个点“…”做参数占位符),实际调用时可以有以下的形式:

printf("%d",i);
printf("%s",s);
printf("the number is %d ,string is:%s", i, s);   

一个简单的可变参数的C函数

     先看例子程序。该函数至少有一个整数参数,其后占位符…,表示后面参数的个数不定。在这个例子里,所有的输入参数必须都是整数,函数的功能只是打印所有参数的值。函数代码如下:

//示例代码1:可变参数函数的使用
#include "stdio.h"
#include "stdarg.h"
void simple_va_fun(int start, ...)
{
    va_list arg_ptr;
    int nArgValue =start;
    int nArgCout="0";  //可变参数的数目
    va_start(arg_ptr,start);  //以固定参数的地址为起点确定变参的内存起始地址。
    do
    {
        ++nArgCout;
        printf("the %d th arg: %d",nArgCout,nArgValue); //输出各参数的值
        nArgValue = va_arg(arg_ptr,int);  //得到下一个可变参数的值
    } while(nArgValue != -1);               
    return;
}
int main(int argc, char* argv[])
{
    simple_va_fun(100,-1);
    simple_va_fun(100,200,-1);
    return 0;
}

下面解释一下这些代码。从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:

⑴由于在程序中将用到以下这些宏:
void va_start( va_list arg_ptr, prev_param );
type va_arg( va_list arg_ptr, type );
void va_end( va_list arg_ptr );
va在这里是variable-argument(可变参数)的意思。
这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个头文件。

⑵函数里首先定义一个va_list型的变量,这里是arg_ptr,这个变量是存储参数地址的指针.因为得到参数的地址之后,再结合参数的类型,才能得到参数的值。

⑶然后用va_start宏初始化⑵中定义的变量arg_ptr,这个宏的第二个参数是可变参数列表的前一个参数,即最后一个固定参数。

⑷然后依次用va_arg宏使arg_ptr返回可变参数的地址,得到这个地址之后,结合参数的类型,就可以得到参数的值。

⑸设定结束条件,这里的条件就是判断参数值是否为-1。注意被调的函数在调用时是不知道可变参数的正确数目的,程序员必须自己在代码中指明结束条件。至于为什么它不会知道参数的数目,在看完这几个宏的内部实现机制后,自然就会明白。

第二篇

C语言之可变参数问题

 

C语言中有一种长度不确定的参数,形如:"…",它主要用在参数个数不确定的函数中,我们最容易想到的例子是printf函数。

  原型:

  int printf( const char *format [, argument]... );

  使用例:

  printf("Enjoy yourself everyday!/n");

  printf("The value is %d!/n", value);

  这种可变参数可以说是C语言一个比较难理解的部分,这里会由几个问题引发一些对它的分析。

  注意:在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任意数量的函数参数。

  问题:printf的实现

  请问,如何自己实现printf函数,如何处理其中的可变参数问题? 答案与分析:

  在标准C语言中定义了一个头文件专门用来对付可变参数列表,它包含了一组宏,和一个va_list的typedef声明。一个典型实现如下:

  typedef char* va_list;

  #define va_start(list) list = (char*)&va_alist

  #define va_end(list)

  #define va_arg(list, mode)/

  ((mode*) (list += sizeof(mode)))[-1]

  自己实现printf:

  #include

  int printf(char* format, …)

  {

  va_list ap;

  va_start(ap, format);

  int n = vprintf(format, ap);

  va_end(ap);

  return n;

  }

  问题:运行时才确定的参数

  有没有办法写一个函数,这个函数参数的具体形式可以在运行时才确定?

  答案与分析:

  目前没有"正规"的解决办法,不过独门偏方倒是有一个,因为有一个函数已经给我们做出了这方面的榜样,那就是main(),它的原型是:

  int main(int argc,char *argv[]);
函数的参数是argc和argv。

  深入想一下,"只能在运行时确定参数形式",也就是说你没办法从声明中看到所接受的参数,也即是参数根本就没有固定的形式。常用的办法是你可以通过定义一个void *类型的参数,用它来指向实际的参数区,然后在函数中根据根据需要任意解释它们的含义。这就是main函数中argv的含义,而argc,则用来表明实际的参数个数,这为我们使用提供了进一步的方便,当然,这个参数不是必需的。

  虽然参数没有固定形式,但我们必然要在函数中解析参数的意义,因此,理所当然会有一个要求,就是调用者和被调者之间要对参数区内容的格式,大小,有效性等所有方面达成一致,否则南辕北辙各说各话就惨了。

  问题:可变长参数的传递

  有时候,需要编写一个函数,将它的可变长参数直接传递给另外的函数,请问,这个要求能否实现?

  答案与分析:

  目前,你尚无办法直接做到这一点,但是我们可以迂回前进,首先,我们定义被调用函数的参数为va_list类型,同时在调用函数中将可变长参数列表转换为va_list,这样就可以进行变长参数的传递了。看如下所示:

  void subfunc (char *fmt, va_list argp)

  {

  ...

  arg = va_arg (fmt, argp); /* 从argp中逐一取出所要的参数 */

  ...

  }

  void mainfunc (char *fmt, ...)

  {

  va_list argp;

  va_start (argp, fmt); /* 将可变长参数转换为va_list */

  subfunc (fmt, argp); /* 将va_list传递给子函数 */

  va_end (argp);

  ...

  }

  问题:可变长参数中类型为函数指针

  我想使用va_arg来提取出可变长参数中类型为函数指针的参数,结果却总是不正确,为什么?

  答案与分析:

  这个与va_arg的实现有关。一个简单的、演示版的va_arg实现如下:

  #define va_arg(argp, type) /

  (*(type *)(((argp) += sizeof(type)) - sizeof(type)))

  其中,argp的类型是char *。

  如果你想用va_arg从可变参数列表中提取出函数指针类型的参数,例如

  int (*)(),则va_arg(argp, int (*)())被扩展为:

  (*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))

  显然,(int (*)() *)是无意义的。

  解决这个问题的办法是将函数指针用typedef定义成一个独立的数据类型,例如:

  typedef int (*funcptr)();

  这时候再调用va_arg(argp, funcptr)将被扩展为:

  (* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))

  这样就可以通过编译检查了。

  问题:可变长参数的获取

  有这样一个具有可变长参数的函数,其中有下列代码用来获取类型为float的实参:

  va_arg (argp, float);

  这样做可以吗?

  答案与分析:

  不可以。在可变长参数中,应用的是"加宽"原则。也就是float类型被扩展成double;char, short被扩展成int。因此,如果你要去可变长参数列表中原来为float类型的参数,需要用va_arg(argp, double)。对char和short类型的则用va_arg(argp, int)。

  问题:定义可变长参数的一个限制

  为什么我的编译器不允许我定义如下的函数,也就是可变长参数,但是没有任何的固定参数?

  int f (...)

  {

  ...

  }

  答案与分析:

  不可以。这是ANSI C 所要求的,你至少得定义一个固定参数。

  这个参数将被传递给va_start(),然后用va_arg()和va_end()来确定所有实际调用时可变长参数的类型和值。
 


Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1386393

---------------------------------------------------------------------------------------------------------------------
如何判别可变参数函数的参数类型?

函数形式如下:
void   fun(char*   str,...)
{
      ......
}

若传的参数个数大于1,如何判别第2个以后传参的参数类型???
最好有源码说明! 


没办法判断的


如楼上所说,例如printf( "%d%c%s ",   ....)是通过格式串中的%d,   %c,   %s来确定后面参数的类型,其实你也可以参考这种方法来判断不定参数的类型.


无法判断。可变参数实现主要通过三个宏实现:va_start,   va_arg,   va_end。

以前貌似有篇文章贴的满天飞啊,我找找看有没有。


找到了,看看可变参数的机制吧:

=====================

一)写一个简单的可变参数的C函数

下面我们来探讨如何写一个简单的可变参数的C函数.写可变参数的
C函数要在程序中用到以下这些宏:
void   va_start(   va_list   arg_ptr,   prev_param   );

type   va_arg(   va_list   arg_ptr,   type   );

void   va_end(   va_list   arg_ptr   );
va在这里是variable-argument(可变参数)的意思.
这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个
头文件.下面我们写一个简单的可变参数的函数,改函数至少有一个整数
参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值.
void   simple_va_fun(int   i,   ...)
{
va_list   arg_ptr;
int   j=0;

va_start(arg_ptr,   i);
j=va_arg(arg_ptr,   int);
va_end(arg_ptr);
printf( "%d   %d/n ",   i,   j);
return;
}
我们可以在我们的头文件中这样声明我们的函数:
extern   void   simple_va_fun(int   i,   ...);
我们在程序中可以这样调用:
simple_va_fun(100);
simple_va_fun(100,200);
从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:
1)首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变
量是指向参数的指针.
2)然后用va_start宏初始化变量arg_ptr,这个宏的第二个参数是第
一个可变参数的前一个参数,是一个固定的参数.
3)然后用va_arg返回可变的参数,并赋值给整数j.   va_arg的第二个
参数是你要返回的参数的类型,这里是int型.
4)最后用va_end宏结束可变参数的获取.然后你就可以在函数里使
用第二个参数了.如果函数有多个可变参数的,依次调用va_arg获
取各个参数.
如果我们用下面三种方法调用的话,都是合法的,但结果却不一样:
1)simple_va_fun(100);
结果是:100   -123456789(会变的值)
2)simple_va_fun(100,200);
结果是:100   200
3)simple_va_fun(100,200,300);
结果是:100   200
我们看到第一种调用有错误,第二种调用正确,第三种调用尽管结果
正确,但和我们函数最初的设计有冲突.下面一节我们探讨出现这些结果
的原因和可变参数在编译器中是如何处理的.

(二)可变参数在编译器中的处理

我们知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,
由于1)硬件平台的不同   2)编译器的不同,所以定义的宏也有所不同,下
面以VC++中stdarg.h里x86平台的宏定义摘录如下( '/ '号表示折行):

typedef   char   *   va_list;

#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   )

定义_INTSIZEOF(n)主要是为了某些需要内存的对齐的系统.C语言的函
数是从右向左压入堆栈的,图(1)是函数的参数在堆栈中的分布位置.我
们看到va_list被定义成char*,有一些平台或操作系统定义为void*.再
看va_start的定义,定义为&v+_INTSIZEOF(v),而&v是固定参数在堆栈的
地址,所以我们运行va_start(ap,   v)以后,ap指向第一个可变参数在堆
栈的地址,如图:

高地址 &brvbar----------------------------- |
|函数返回地址   |
&brvbar----------------------------- |
&brvbar.......   |
&brvbar----------------------------- |
|第n个参数(第一个可变参数)   |
&brvbar----------------------------- | <--va_start后ap指向
|第n-1个参数(最后一个固定参数) |
低地址 &brvbar----------------------------- | <--   &v
图(   1   )

然后,我们用va_arg()取得类型t的可变参数值,以上例为int型为例,我
们看一下va_arg取int型的返回值:
j=   (   *(int*)((ap   +=   _INTSIZEOF(int))-_INTSIZEOF(int))   );
首先ap+=sizeof(int),已经指向下一个参数的地址了.然后返回
ap-sizeof(int)的int*指针,这正是第一个可变参数在堆栈里的地址
(图2).然后用*取得这个地址的内容(参数值)赋给j.

高地址 &brvbar----------------------------- |
|函数返回地址   |
&brvbar----------------------------- |
&brvbar.......   |
&brvbar----------------------------- | <--va_arg后ap指向
|第n个参数(第一个可变参数)   |
&brvbar----------------------------- | <--va_start后ap指向
|第n-1个参数(最后一个固定参数) |
低地址 &brvbar----------------------------- | <--   &v
图(   2   )

最后要说的是va_end宏的意思,x86平台定义为ap=(char*)0;使ap不再
指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不
会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的.
在这里大家要注意一个问题:由于参数的地址用于va_start宏,所
以参数不能声明为寄存器变量或作为函数或数组类型.
关于va_start,   va_arg,   va_end的描述就是这些了,我们要注意的
是不同的操作系统和硬件平台的定义有些不同,但原理却是相似的.

(三)可变参数在编程中要注意的问题

因为va_start,   va_arg,   va_end等定义成宏,所以它显得很愚蠢,
可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能
地识别不同参数的个数和类型.
有人会问:那么printf中不是实现了智能识别参数吗?那是因为函数
printf是从固定参数format字符串来分析出参数的类型,再调用va_arg
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
过在自己的程序里作判断来实现的.
另外有一个问题,因为编译器对可变参数的函数的原型检查不够严
格,对编程查错不利.如果simple_va_fun()改为:
void   simple_va_fun(int   i,   ...)
{
va_list   arg_ptr;
char   *s=NULL;

va_start(arg_ptr,   i);
s=va_arg(arg_ptr,   char*);
va_end(arg_ptr);
printf( "%d   %s/n ",   i,   s);
return;
}
可变参数为char*型,当我们忘记用两个参数来调用该函数时,就会出现
core   dump(Unix)   或者页面非法的错误(window平台).但也有可能不出
错,但错误却是难以发现,不利于我们写出高质量的程序.
以下提一下va系列宏的兼容性.
System   V   Unix把va_start定义为只有一个参数的宏:
va_start(va_list   arg_ptr);
而ANSI   C则定义为:
va_start(va_list   arg_ptr,   prev_param);
如果我们要用system   V的定义,应该用vararg.h头文件中所定义的
宏,ANSI   C的宏跟system   V的宏是不兼容的,我们一般都用ANSI   C,所以
用ANSI   C的定义就够了,也便于程序的移植. 



参数类型是无法判断,
只能在你的函数处理中定义   ...

比如你定义一个   int   max(int   num,   ...)
只能是定义好传入的参数都是   int   ,只是数目不定,
而不是类型不定   ...



前言:本文在很大程度上改编自网友kevintz的“C语言中可变参数的用法”一文,在行文之前先向这位前辈表示真诚的敬意和感谢。

一、什么是可变参数

我们在C语言编程中有时会遇到一些参数个数可变的函数,例如printf()函数,其函数原型为:  

int   printf(   const   char*   format,   ...);  

它除了有一个参数format固定以外,后面跟的参数的个数和类型是可变的(用三个点“…”做参数占位符),实际调用时可以有以下的形式:   printf( "%d ",i);  

printf( "%s ",s);  

printf( "the   number   is   %d   ,string   is:%s ",   i,   s);        

以上这些东西已为大家所熟悉。但是究竟如何写可变参数的C函数以及这些可变参数的函数编译器是如何实现,这个问题却一直困扰了我好久。本文就这个问题进行一些探讨,希望能对大家有些帮助.

 

二、写一个简单的可变参数的C函数  

先看例子程序。该函数至少有一个整数参数,其后占位符…,表示后面参数的个数不定.   在这个例子里,所有的输入参数必须都是整数,函数的功能只是打印所有参数的值.

函数代码如下:

//示例代码1:可变参数函数的使用

#include   "stdio.h "

#include   "stdarg.h "

void   simple_va_fun(int   start,   ...)  

{  

        va_list   arg_ptr;  

        int   nArgValue   =start;

        int   nArgCout=0;           //可变参数的数目

        va_start(arg_ptr,start);   //以固定参数的地址为起点确定变参的内存起始地址。

        do  

        {

                ++nArgCout;

                printf( "the   %d   th   arg:   %d/n ",nArgCout,nArgValue);           //输出各参数的值

                nArgValue   =   va_arg(arg_ptr,int);                                             //得到下一个可变参数的值

        }   while(nArgValue   !=   -1);                                

        return;  

}

int   main(int   argc,   char*   argv[])

{

        simple_va_fun(100,-1);  

        simple_va_fun(100,200,-1);  

              return   0;

}

下面解释一下这些代码

从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:  

⑴由于在程序中将用到以下这些宏:  

void   va_start(   va_list   arg_ptr,   prev_param   );  

type   va_arg(   va_list   arg_ptr,   type   );  

void   va_end(   va_list   arg_ptr   );  

va在这里是variable-argument(可变参数)的意思.  

这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个头文件.

⑵函数里首先定义一个va_list型的变量,这里是arg_ptr,这个变  

量是存储参数地址的指针.因为得到参数的地址之后,再结合参数的类型,才能得到参数的值。

⑶然后用va_start宏初始化⑵中定义的变量arg_ptr,这个宏的第二个参数是可变参数列表的前一个参数,即最后一个固定参数.  

⑷然后依次用va_arg宏使arg_ptr返回可变参数的地址,得到这个地址之后,结合参数的类型,就可以得到参数的值。

⑸设定结束条件,这里的条件就是判断参数值是否为-1。注意被调的函数在调用时是不知道可变参数的正确数目的,程序员必须自己在代码中指明结束条件。至于为什么它不会知道参数的数目,读者在看完这几个宏的内部实现机制后,自然就会明白。

 

(二)可变参数在编译器中的处理  

我们知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,   由于1)硬件平台的不同   2)编译器的不同,所以定义的宏也有所不同,下面看一下VC++6.0中stdarg.h里的代码(文件的路径为VC安装目录下的/vc98/ include/stdarg.h)

typedef   char   *     va_list;

#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   )

下面我们解释这些代码的含义:

1、首先把va_list被定义成char*,这是因为在我们目前所用的PC机上,字符指针类型可以用来存储内存单元地址。而在有的机器上va_list是被定义成void*的

2、定义_INTSIZEOF(n)主要是为了某些需要内存的对齐的系统.这个宏的目的是为了得到最后一个固定参数的实际内存大小。在我的机器上直接用sizeof运算符来代替,对程序的运行结构也没有影响。(后文将看到我自己的实现)。

3、va_start的定义为   &v+_INTSIZEOF(v)   ,这里&v是最后一个固定参数的起始地址,再加上其实际占用大小后,就得到了第一个可变参数的起始内存地址。所以我们运行va_start (ap,   v)以后,ap指向第一个可变参数在的内存地址,有了这个地址,以后的事情就简单了。  

这里要知道两个事情:

        ⑴在intel+windows的机器上,函数栈的方向是向下的,栈顶指针的内存地址低于栈底指针,所以先进栈的数据是存放在内存的高地址处。

        (2)在VC等绝大多数C编译器中,默认情况下,参数进栈的顺序是由右向左的,因此,参数进栈以后的内存模型如下图所示:最后一个固定参数的地址位于第一个可变参数之下,并且是连续存储的。

|—————————————————————————— |

|     最后一个可变参数                           |       -> 高内存地址处

|—————————————————————————— |

      ...................

|—————————————————————————— |

|     第N个可变参数                             |           -> va_arg(arg_ptr,int)后arg_ptr所指的地方,

|                                                               |           即第N个可变参数的地址。

|———————————————   |          

      ………………………….

|—————————————————————————— |

|     第一个可变参数                               |           -> va_start(arg_ptr,start)后arg_ptr所指的地方

|                                                               |           即第一个可变参数的地址

|———————————————   |          

|————————————————————————   —— |

|                                                               |

|     最后一个固定参数                           |         ->   start的起始地址

|——————————————   — |               .................

|——————————————————————————   |

|                                                               |    

|———————————————   |     ->   低内存地址处

 

(4)   va_arg():有了va_start的良好基础,我们取得了第一个可变参数的地址,在va_arg()里的任务就是根据指定的参数类型取得本参数的值,并且把指针调到下一个参数的起始地址。

因此,现在再来看va_arg()的实现就应该心中有数了:

#define   va_arg(ap,t)         (   *(t   *)((ap   +=   _INTSIZEOF(t))   -   _INTSIZEOF(t))   )

这个宏做了两个事情,

              ①用用户输入的类型名对参数地址进行强制类型转换,得到用户所需要的值

      ②计算出本参数的实际大小,将指针调到本参数的结尾,也就是下一个参数的首地址,以便后续处理。

(5)va_end宏的解释:x86平台定义为ap=(char*)0;使ap不再   指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的.   在这里大家要注意一个问题:由于参数的地址用于va_start宏,所以参数不能声明为寄存器变量或作为函数或数组类型.   关于va_start,   va_arg,   va_end的描述就是这些了,我们要注意的   是不同的操作系统和硬件平台的定义有些不同,但原理却是相似的.

 

(三)可变参数在编程中要注意的问题  

因为va_start,   va_arg,   va_end等定义成宏,所以它显得很愚蠢,   可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能   地识别不同参数的个数和类型.   有人会问:那么printf中不是实现了智能识别参数吗?那是因为函数   printf是从固定参数format字符串来分析出参数的类型,再调用va_arg   的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的.   例如,在C的经典教材《the   c   programming   language》的7.3节中就给出了一个printf的可能实现方式,由于篇幅原因这里不再叙述。

(四)小结:  

1、标准C库的中的三个宏的作用只是用来确定可变参数列表中每个参数的内存地址,编译器是不知道参数的实际数目的。

2、在实际应用的代码中,程序员必须自己考虑确定参数数目的办法,如

⑴在固定参数中设标志——   printf函数就是用这个办法。后面也有例子。

⑵在预先设定一个特殊的结束标记,就是说多输入一个可变参数,调用时要将最后一个可变参数的值设置成这个特殊的值,在函数体中根据这个值判断是否达到参数的结尾。本文前面的代码就是采用这个办法.

无论采用哪种办法,程序员都应该在文档中告诉调用者自己的约定。

3、实现可变参数的要点就是想办法取得每个参数的地址,取得地址的办法由以下几个因素决定:

①函数栈的生长方向

②参数的入栈顺序

③CPU的对齐方式

④内存地址的表达方式

结合源代码,我们可以看出va_list的实现是由④决定的,_INTSIZEOF(n)的引入则是由③决定的,他和①②又一起决定了va_start的实现,最后va_end的存在则是良好编程风格的体现,将不再使用的指针设为NULL,这样可以防止以后的误操作。

4、取得地址后,再结合参数的类型,程序员就可以正确的处理参数了。理解了以上要点,相信稍有经验的读者就可以写出适合于自己机器的实现来。下面就是一个例子



用模板可以实现
template <class   T,   class   T2>
T   sum(T   a,   T2   b,   ....)
可以实现的


不能判断

一般通过第一个参数   format   得到后面的类型



吧上边的代码一改
template <class   T,   class   T2>
T   t_max(T   start,T2   next...)  
{  
        T   result   =   0;
        va_list   arg_ptr;  
        T   nArgValue   =start;

        va_start(arg_ptr,start);   //以固定参数的地址为起点确定变参的内存起始地址。
        do  
        {
              result   +=   nArgValue;
              cout < <typeid(nArgValue).name() < <endl;//显示类型
                nArgValue   =   va_arg(arg_ptr,int);       //得到下一个可变参数的值

        }   while(nArgValue   !=   static_cast <T2> (-1));                                
        return;  
}

调用时

cout < <t_max <int,   int> (1,   2,   1,   2,   -1);
就可以 





T   t_max(T   start,T2   next...)  
-- 
T   t_max(T   start,T2   next,...)


nArgValue   =   va_arg(arg_ptr,int);       //得到下一个可变参数的值
---
nArgValue   =   static_cast <T> (va_arg(arg_ptr,int));       //得到下一个可变参数的值 



可变参数,可以参考printf原形的机制



    
发表于:2007-06-26 19:03:3312楼 得分:0
上面写的我在网上也找到过,但还是没有解决问题。若函数调用是以下形式,就不能解决。
fun( "c ",1,1.2, "str ",2)



    
发表于:2007-06-27 10:16:2313楼 得分:0
可变参现在用的不多了吧.



    
发表于:2007-06-27 11:39:0614楼 得分:0
函数形式如下:
void   fun(char*   str,...)
{
      ......
}

若传的参数个数大于1,如何判别第2个以后传参的参数类型???
最好有源码说明!
===========================
可以分析str,   黨找到%d的時候對應就是int



    
发表于:2007-06-27 11:40:5115楼 得分:0
這種映射需要手動來寫



    
发表于:2007-06-27 11:56:2216楼 得分:0
这样做有意义吗?



    
发表于:2007-06-27 12:15:0617楼 得分:0




    
发表于:2007-06-27 12:30:4618楼 得分:0
就因为无法判断,才会有那么多的printf   scanf错误



    
发表于:2007-06-27 13:42:1019楼 得分:0
NO   WAY,C/C++   不提供这种机制。


    
发表于:2007-06-27 16:42:0520楼 得分:0
very   good,   mark


    
发表于:2007-06-27 18:01:2221楼 得分:0
没什么意义,反正编译成汇编就32位整型一种类型

    
发表于:2007-06-28 08:48:1322楼 得分:0
没什么意义,....
=============

這樣做方便我們剪裁程序大小,   如果手工寫一個適合自己得函數,   將會大大縮小程序的體積

比如sprintf這個,   如果你自己手工寫一個很可能節約千行得代碼區

    
发表于:2007-06-28 09:00:1823楼 得分:0
没办法的,你可以参考一下boost的format的办法.

---------------------------------------------------------------------------------------------------------------------
水滴石穿C语言之可变参数问题
作者:C++教程 来源:http://d9soft.com 时间:2006-2-22 5:43:08


C语言中有一种长度不确定的参数,形如:"…",它主要用在参数个数不确定的函数中,我们最容易想到的例子是printf函数。

  原型:

  int printf( const char *format [, argument]... );

  使用例:

  printf("Enjoy yourself everyday!/n");

  printf("The value is %d!/n", value);

  这种可变参数可以说是C语言一个比较难理解的部分,这里会由几个问题引发一些对它的分析。

  注意:在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任意数量的函数参数。

  问题:printf的实现

  请问,如何自己实现printf函数,如何处理其中的可变参数问题? 答案与分析:

  在标准C语言中定义了一个头文件专门用来对付可变参数列表,它包含了一组宏,和一个va_list的typedef声明。一个典型实现如下:

  typedef char* va_list;

  #define va_start(list) list = (char*)&va_alist

  #define va_end(list)

  #define va_arg(list, mode)/

  ((mode*) (list += sizeof(mode)))[-1]

  自己实现printf:

  #include

  int printf(char* format, …)

  {

  va_list ap;

  va_start(ap, format);

  int n = vprintf(format, ap);

  va_end(ap);

  return n;

  }

  问题:运行时才确定的参数

  有没有办法写一个函数,这个函数参数的具体形式可以在运行时才确定?

  答案与分析:

  目前没有"正规"的解决办法,不过独门偏方倒是有一个,因为有一个函数已经给我们做出了这方面的榜样,那就是main(),它的原型是:

  int main(int argc,char *argv[]);
函数的参数是argc和argv。

  深入想一下,"只能在运行时确定参数形式",也就是说你没办法从声明中看到所接受的参数,也即是参数根本就没有固定的形式。常用的办法是你可以通过定义一个void *类型的参数,用它来指向实际的参数区,然后在函数中根据根据需要任意解释它们的含义。这就是main函数中argv的含义,而argc,则用来表明实际的参数个数,这为我们使用提供了进一步的方便,当然,这个参数不是必需的。

  虽然参数没有固定形式,但我们必然要在函数中解析参数的意义,因此,理所当然会有一个要求,就是调用者和被调者之间要对参数区内容的格式,大小,有效性等所有方面达成一致,否则南辕北辙各说各话就惨了。

  问题:可变长参数的传递

  有时候,需要编写一个函数,将它的可变长参数直接传递给另外的函数,请问,这个要求能否实现?

  答案与分析:

  目前,你尚无办法直接做到这一点,但是我们可以迂回前进,首先,我们定义被调用函数的参数为va_list类型,同时在调用函数中将可变长参数列表转换为va_list,这样就可以进行变长参数的传递了。看如下所示:

  void subfunc (char *fmt, va_list argp)

  {

  ...

  arg = va_arg (fmt, argp); /* 从argp中逐一取出所要的参数 */

  ...

  }

  void mainfunc (char *fmt, ...)

  {

  va_list argp;

  va_start (argp, fmt); /* 将可变长参数转换为va_list */

  subfunc (fmt, argp); /* 将va_list传递给子函数 */

  va_end (argp);

  ...

  }

  问题:可变长参数中类型为函数指针

  我想使用va_arg来提取出可变长参数中类型为函数指针的参数,结果却总是不正确,为什么?

  答案与分析:

  这个与va_arg的实现有关。一个简单的、演示版的va_arg实现如下:

  #define va_arg(argp, type) /

  (*(type *)(((argp) += sizeof(type)) - sizeof(type)))

  其中,argp的类型是char *。

  如果你想用va_arg从可变参数列表中提取出函数指针类型的参数,例如

  int (*)(),则va_arg(argp, int (*)())被扩展为:

  (*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))

  显然,(int (*)() *)是无意义的。

  解决这个问题的办法是将函数指针用typedef定义成一个独立的数据类型,例如:

  typedef int (*funcptr)();

  这时候再调用va_arg(argp, funcptr)将被扩展为:

  (* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))

  这样就可以通过编译检查了。

  问题:可变长参数的获取

  有这样一个具有可变长参数的函数,其中有下列代码用来获取类型为float的实参:

  va_arg (argp, float);

  这样做可以吗?

  答案与分析:

  不可以。在可变长参数中,应用的是"加宽"原则。也就是float类型被扩展成double;char, short被扩展成int。因此,如果你要去可变长参数列表中原来为float类型的参数,需要用va_arg(argp, double)。对char和short类型的则用va_arg(argp, int)。

  问题:定义可变长参数的一个限制

  为什么我的编译器不允许我定义如下的函数,也就是可变长参数,但是没有任何的固定参数?

  int f (...)

  {

  ...

  }

  答案与分析:

  不可以。这是ANSI C 所要求的,你至少得定义一个固定参数。

  这个参数将被传递给va_start(),然后用va_arg()和va_end()来确定所有实际调用时可变长参数的类型和值。

---------------------------------------------------------------------------------------------------------------------
函数的可变参数详谈
作者:neverTheSame    文章来源:本站原创    点击数:988    更新时间:2007-10-8 10:47:51
 

原帖及讨论:http://bbs.bc-cn.net/dispbbs.asp?boardid=5&id=175137

*/ --------------------------------------------------------------------------------------
*/ 出自: 编程中国  http://www.bc-cn.net
*/ 作者: neverTheSame    E-mail:zhaoxufeng9997@126.com    QQ:475818502
*/ 时间: 2007-10-5  编程论坛首发
*/ 声明: 尊重作者劳动,转载请保留本段文字
*/ --------------------------------------------------------------------------------------


可变参数的英文表示为:variable argument.
它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.
可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不
定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有
实际的名称与之相对应.
由此可见,可变参数的形式非常*而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.
然而,更多地*,同样也加大操作上的难度.
以下就对可变参数的几个方面作一定的介绍.

1)可变参数的存储形式.

大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,
存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.
在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,
这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.
因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):
栈区:

|栈顶             低地址

|第一个固定参数var1
|可变参数前的第一个固定参数var2
|可变参数的第一个参数
|...
|可变参数的最后一个参数
|函数的倒数第二个固定参数var3
|函数的最后一个固定参数var4
|...
|函数的返回地址
|...
|栈底    高地址

2)使用可变参数所用到头文件和相关宏说明

在此,以TC2.0编译器为参考对象来说明.
可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.
此文件为:
/* stdarg.h

Definitions for ACCESSing parameters in functions that accept
a variable number of arguments.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

#if !defined(__STDARG)
#define __STDARG

typedef void *va_list;

#define va_start(ap, parmN) (ap = ...)
#define va_arg(ap, type) (*((type *)(ap))++)
#define va_end(ap)
#define _va_ptr   (...)
#endif

以上为"STDARG.H"的内容.
该文件定义了使用可变参数所用到的数据类型:typedef void  *va_list;
va_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,
parmN为可变参数的前面一个固定参数.
va_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.
va_end(ap) 结束可变参数获取.

3)可变参数的使用实例

实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.

#include<stdio.h>
#include<conio.h>
#include<stdarg.h>
void tVarArg(int num,...);/*num为可变参数的个数*/
int main(void)
{
clrscr();
tVarArg(5,"Hello! ","My ","name ","is ","neverTheSame./n");
tVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");
getch();
return 0;
}
void tVarArg(int num,...)
{
va_list argp;  /*定义一个指向可变参数的变量*/
va_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/
while(--num>=0)
  printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,
    并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/
va_end(argp);  /*结束可变参数获取*/
return ;
}

4)可变参数的使用需要注意的问题

1.每个函数的可变参数至多有一个.
2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.
3.可变参数的个数不确定,完全由程序约定.
4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.
而printf()中不是实现了识别参数吗?那是因为函数
printf()是从固定参数format字符串来分析出参数的类型,再调用va_arg
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
过在自己的程序里作判断来实现的.
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高.

---------------------------------------------------------------------------------------------------------------------
    C语言中可变参数的用法

    我们在C语言编程中会遇到一些参数个数可变的函数,例如printf()
这个函数,它的定义是这样的:
    int printf( const char* format, ...);
    它除了有一个参数format固定以外,后面跟的参数的个数和类型是
可变的,例如我们可以有以下不同的调用方法:
    printf("%d",i);
    printf("%s",s);
    printf("the number is %d ,string is:%s", i, s);
究竟如何写可变参数的C函数以及这些可变参数的函数编译器是如何实
现的呢?本文就这个问题进行一些探讨,希望能对大家有些帮助.会C++的
网友知道这些问题在C++里不存在,因为C++具有多态性.但C++是C的一个
超集,以下的技术也可以用于C++的程序中.限于本人的水平,文中如果有
不当之处,请大家指正.

              (一)写一个简单的可变参数的C函数

    下面我们来探讨如何写一个简单的可变参数的C函数.写可变参数的
C函数要在程序中用到以下这些宏:
    void va_start( va_list arg_ptr, prev_param );

    type va_arg( va_list arg_ptr, type );

    void va_end( va_list arg_ptr );
    va在这里是variable-argument(可变参数)的意思.
    这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个
头文件.下面我们写一个简单的可变参数的函数,改函数至少有一个整数
参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值.
    void simple_va_fun(int i, ...)
    {
        va_list arg_ptr;
        int j=0;
          
        va_start(arg_ptr, i);
        j=va_arg(arg_ptr, int);
        va_end(arg_ptr);
        printf("%d %d/n", i, j);
        return;
    }
    我们可以在我们的头文件中这样声明我们的函数:
    extern void simple_va_fun(int i, ...);
    我们在程序中可以这样调用:
    simple_va_fun(100);
    simple_va_fun(100,200);
    从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:
    1)首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变
      量是指向参数的指针.
    2)然后用va_start宏初始化变量arg_ptr,这个宏的第二个参数是第
      一个可变参数的前一个参数,是一个固定的参数.
    3)然后用va_arg返回可变的参数,并赋值给整数j. va_arg的第二个
      参数是你要返回的参数的类型,这里是int型.
    4)最后用va_end宏结束可变参数的获取.然后你就可以在函数里使
      用第二个参数了.如果函数有多个可变参数的,依次调用va_arg获
      取各个参数.
    如果我们用下面三种方法调用的话,都是合法的,但结果却不一样:
    1)simple_va_fun(100);
      结果是:100 -123456789(会变的值)
    2)simple_va_fun(100,200);
      结果是:100 200
    3)simple_va_fun(100,200,300);
      结果是:100 200
    我们看到第一种调用有错误,第二种调用正确,第三种调用尽管结果
正确,但和我们函数最初的设计有冲突.下面一节我们探讨出现这些结果
的原因和可变参数在编译器中是如何处理的.
 
              (二)可变参数在编译器中的处理

    我们知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,
由于1)硬件平台的不同 2)编译器的不同,所以定义的宏也有所不同,下
面以VC++中stdarg.h里x86平台的宏定义摘录如下('/'号表示折行):

typedef char * va_list;

#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 )

定义_INTSIZEOF(n)主要是为了某些需要内存的对齐的系统.C语言的函
数是从右向左压入堆栈的,图(1)是函数的参数在堆栈中的分布位置.我
们看到va_list被定义成char*,有一些平台或操作系统定义为void*.再
看va_start的定义,定义为&v+_INTSIZEOF(v),而&v是固定参数在堆栈的
地址,所以我们运行va_start(ap, v)以后,ap指向第一个可变参数在堆
栈的地址,如图:

  高地址
|-----------------------------|
|.......                      |
|-----------------------------|
|第n个参数(第一个可变参数)    |
|----------------------------|<--va_start后ap指向
|第n-1个参数(最后一个固定参数)|
|-----------------------------|<-- &v
|函数返回地址 |
|----------------------------|
低地址

图( 1 )

然后,我们用va_arg()取得类型t的可变参数值,以上例为int型为例,我
们看一下va_arg取int型的返回值:
j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );
首先ap+=sizeof(int),已经指向下一个参数的地址了.然后返回
ap-sizeof(int)的int*指针,这正是第一个可变参数在堆栈里的地址
(图2).然后用*取得这个地址的内容(参数值)赋给j.

高地址
|-----------------------------|
|....... |
|-----------------------------|<--va_arg后ap指向
|第n个参数(第一个可变参数) |
|-----------------------------|<--va_start后ap指向
|第n-1个参数(最后一个固定参数)|
|-----------------------------|<-- &v
|函数返回地址 |
|----------------------------|
低地址
图( 2 )

最后要说的是va_end宏的意思,x86平台定义为ap=(char*)0;使ap不再
指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不
会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的.
在这里大家要注意一个问题:由于参数的地址用于va_start宏,所
以参数不能声明为寄存器变量或作为函数或数组类型.
关于va_start, va_arg, va_end的描述就是这些了,我们要注意的
是不同的操作系统和硬件平台的定义有些不同,但原理却是相似的.

(三)可变参数在编程中要注意的问题

因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,
可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能
地识别不同参数的个数和类型.
有人会问:那么printf中不是实现了智能识别参数吗?那是因为函数
printf是从固定参数format字符串来分析出参数的类型,再调用va_arg
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
过在自己的程序里作判断来实现的.
另外有一个问题,因为编译器对可变参数的函数的原型检查不够严
格,对编程查错不利.如果simple_va_fun()改为:
void simple_va_fun(int i, ...)
{
va_list arg_ptr;
char *s=NULL;

va_start(arg_ptr, i);
s=va_arg(arg_ptr, char*);
va_end(arg_ptr);
printf("%d %s/n", i, s);
return;
}
可变参数为char*型,当我们忘记用两个参数来调用该函数时,就会出现
core dump(Unix) 或者页面非法的错误(window平台).但也有可能不出
错,但错误却是难以发现,不利于我们写出高质量的程序.
以下提一下va系列宏的兼容性.
System V Unix把va_start定义为只有一个参数的宏:
va_start(va_list arg_ptr);
而ANSI C则定义为:
va_start(va_list arg_ptr, prev_param);
如果我们要用system V的定义,应该用vararg.h头文件中所定义的
宏,ANSI C的宏跟system V的宏是不兼容的,我们一般都用ANSI C,所以
用ANSI C的定义就够了,也便于程序的移植.


小结:
可变参数的函数原理其实很简单,而va系列是以宏定义来定义的,实
现跟堆栈相关.我们写一个可变函数的C函数时,有利也有弊,所以在不必
要的场合,我们无需用到可变参数.如果在C++里,我们应该利用C++的多
态性来实现可变参数的功能,尽量避免用C语言的方式来实现.

写这篇文章时,适逢感冒,多得有她的关怀,谨把这篇文章献给她...

 


for example:

int dprintf(int level, const char *format, ...)
{
    int     rc = 0;
    va_list argList;
   
    REQUIRE(format);
   
    if(level >= 0 && debugLevel >= level)
    {
        va_start(argList, format);
        rc = vprintf(format, argList);
        va_end(argList);
    }
   
    return rc;


---------------------------------------------------------------------------------------------------------------------
C语言深入浅出可变参数函数的使用技巧(转)

2006-11-24 09:15

深入浅出可变参数函数的使用技巧本文主要介绍可变参数的函数使用,然后分析它的原理,程序员自己如何对它们实
现和封装,最后是可能会出现的问题和避免措施。

VA函数(variable argument function),参数个数可变函数,又称可变参数函数
。C/C++编程中,系统提供给编程人员的va函数很少。*printf()/*scanf()系列函数
,用于输入输出时格式化字符串;exec*()系列函数,用于在程序中执行外部文件(
main(int argc,char*argv[]算不算呢,与其说main()也是一个可变参数函数,倒不
如说它是exec*()经过封装后的具备特殊功能和意义的函数,至少在原理这一级上有
很多相似之处)。由于参数个数的不确定,使va函数具有很大的灵活性,易用性,对
没有使用过可变参数函数的编程人员很有诱惑力;那么,该如何编写自己的va函数
,va函数的运用时机、编译实现又是如何。作者借本文谈谈自己关于va函数的一些
浅见。

一、 从printf()开始

从大家都很熟悉的格式化字符串函数开始介绍可变参数函数。

原型:int printf(const char * format, ...);

参数format表示如何来格式字符串的指令,…

表示可选参数,调用时传递给"..."的参数可有可无,根据实际情况而定。

系统提供了vprintf系列格式化字符串的函数,用于编程人员封装自己的I/O函数。


int vprintf / vscanf(const char * format, va_list ap); // 从标准输入/输出
格式化字符串

int vfprintf / vfsacanf(FILE * stream, const char * format, va_list ap);
// 从文件流

int vsprintf / vsscanf(char * s, const char * format, va_list ap); // 从
字符串

// 例1:格式化到一个文件流,可用于日志文件

FILE *logfile;

int WriteLog(const char * format, ...)

{

va_list arg_ptr;

va_start(arg_ptr, format);

int nWrittenBytes = vfprintf(logfile, format, arg_ptr);

va_end(arg_ptr);

return nWrittenBytes;

}



// 调用时,与使用printf()没有区别。

WriteLog("%04d-%02d-%02d %02d:%02d:%02d  %s/%04d logged out.",

nYear, nMonth, nDay, nHour, nMinute, szUserName, nUserID);

 

同理,也可以从文件中执行格式化输入;或者对标准输入输出,字符串执行格式化


在上面的例1中,WriteLog()函数可以接受参数个数可变的输入,本质上,它的实现
需要vprintf()的支持。如何真正实现属于自己的可变参数函数,包括控制每一个传
入的可选参数。

二、 va函数的定义和va宏

C语言支持va函数,作为C语言的扩展--C++同样支持va函数,但在C++中并不推荐使
用,C++引入的多态性同样可以实现参数个数可变的函数。不过,C++的重载功能毕
竟只能是有限多个可以预见的参数个数。比较而言,C中的va函数则可以定义无穷多
个相当于C++的重载函数,这方面C++是无能为力的。va函数的优势表现在使用的方
便性和易用性上,可以使代码更简洁。C编译器为了统一在不同的硬件架构、硬件平
台上的实现,和增加代码的可移植性,提供了一系列宏来屏蔽硬件环境不同带来的
差异。

ANSI C标准下,va的宏定义在stdarg.h中,它们有:va_list,va_start(),va_ar
g(),va_end()。

// 例2:求任意个自然数的平方和:

int SqSum(int n1, ...)

{

va_list arg_ptr;

int nSqSum = 0, n = n1;

va_start(arg_ptr, n1);

while (n > 0)

{

    nSqSum += (n * n);

    n = va_arg(arg_ptr, int);

}

va_end(arg_ptr);

return nSqSum;

}

// 调用时

int nSqSum = SqSum(7, 2, 7, 11, -1);

 

可变参数函数的原型声明格式为:

type VAFunction(type arg1, type arg2, … );

参数可以分为两部分:个数确定的固定参数和个数可变的可选参数。函数至少需要
一个固定参数,固定参数的声明和普通函数一样;可选参数由于个数不确定,声明
时用"…"表示。固定参数和可选参数公同构成一个函数的参数列表。

借助上面这个简单的例2,来看看各个va_xxx的作用。

va_list arg_ptr:定义一个指向个数可变的参数列表指针;

va_start(arg_ptr, argN):使参数列表指针arg_ptr指向函数参数列表中的第一个
可选参数,说明:argN是位于第一个可选参数之前的固定参数,(或者说,最后一
个固定参数;…之前的一个参数),函数参数列表中参数在内存中的顺序与函数声
明时的顺序是一致的。如果有一va函数的声明是void va_test(char a, char b, c
har c, …),则它的固定参数依次是a,b,c,最后一个固定参数argN为c,因此就是
va_start(arg_ptr, c)。

va_arg(arg_ptr, type):返回参数列表中指针arg_ptr所指的参数,返回类型为ty
pe,并使指针arg_ptr指向参数列表中下一个参数。

va_copy(dest, src):dest,src的类型都是va_list,va_copy()用于复制参数列表
指针,将dest初始化为src。

va_end(arg_ptr):清空参数列表,并置参数指针arg_ptr无效。说明:指针arg_pt
r被置无效后,可以通过调用va_start()、va_copy()恢复arg_ptr。每次调用va_st
art() / va_copy()后,必须得有相应的va_end()与之匹配。参数指针可以在参数列
表中随意地来回移动,但必须在va_start() … va_end()之内。

---------------------------------------------------------------------------------------------------------------------
[转]可变参数函数的实现--VA函数



本文主要介绍可变参数的函数使用,然后分析它的原理,程序员自己如何对它们实现和封装,最后是可能会出现的问题和避免措施。

VA函数(variable argument function),参数个数可变函数,又称可变参数函数。C/C++编程中,系统提供给编程人员的va函数很少。*printf()/*scanf() 系列函数,用于输入输出时格式化字符串;exec*()系列函数,用于在程序中执行外部文件(main(int argc,char*argv[]算不算呢,与其说main()也是一个可变参数函数,倒不如说它是exec*()经过封装后的具备特殊功能和意义的函数,至少在原理这一级上有很多相似之处)。由于参数个数的不确定,使va函数具有很大的灵活性,易用性,对没有使用过可变参数函数的编程人员很有诱惑力;那么,该如何编写自己的va函数,va函数的运用时机、编译实现又是如何。作者借本文谈谈自己关于va函数的一些浅见。

一、 从printf()开始

从大家都很熟悉的格式化字符串函数开始介绍可变参数函数。

原型:int printf(const char * format, ...);

参数format表示如何来格式字符串的指令,…

表示可选参数,调用时传递给"..."的参数可有可无,根据实际情况而定。

系统提供了vprintf系列格式化字符串的函数,用于编程人员封装自己的I/O函数。

int vprintf / vscanf(const char * format, va_list ap); // 从标准输入/输出格式化字符串

int vfprintf / vfsacanf(FILE * stream, const char * format, va_list ap); // 从文件流

int vsprintf / vsscanf(char * s, const char * format, va_list ap); // 从字符串

// 例1:格式化到一个文件流,可用于日志文件


FILE *logfile;
int WriteLog(const char * format, ...)
{
va_list arg_ptr;

va_start(arg_ptr, format);
int nWrittenBytes = vfprintf(logfile, format, arg_ptr);
va_end(arg_ptr);

return nWrittenBytes;
}

// 调用时,与使用printf()没有区别。
WriteLog("%04d-%02d-%02d %02d:%02d:%02d  %s/%04d logged out.", 
nYear, nMonth, nDay, nHour, nMinute, szUserName, nUserID);



同理,也可以从文件中执行格式化输入;或者对标准输入输出,字符串执行格式化。

在上面的例1中,WriteLog()函数可以接受参数个数可变的输入,本质上,它的实现需要vprintf()的支持。如何真正实现属于自己的可变参数函数,包括控制每一个传入的可选参数。

二、 va函数的定义和va宏

C语言支持va函数,作为C语言的扩展--C++同样支持va函数,但在C++中并不推荐使用,C++引入的多态性同样可以实现参数个数可变的函数。不过,C++的重载功能毕竟只能是有限多个可以预见的参数个数。比较而言,C中的va函数则可以定义无穷多个相当于C++的重载函数,这方面C++是无能为力的。va函数的优势表现在使用的方便性和易用性上,可以使代码更简洁。C编译器为了统一在不同的硬件架构、硬件平台上的实现,和增加代码的可移植性,提供了一系列宏来屏蔽硬件环境不同带来的差异。

ANSI C标准下,va的宏定义在stdarg.h中,它们有:va_list,va_start(),va_arg(),va_end()。

// 例2:求任意个自然数的平方和:


int SqSum(int n1, ...)
{
va_list arg_ptr;
int nSqSum = 0, n = n1;

va_start(arg_ptr, n1);
while (n > 0)
{
    nSqSum += (n * n);
    n = va_arg(arg_ptr, int);
}
va_end(arg_ptr);

return nSqSum;
}

// 调用时
int nSqSum = SqSum(7, 2, 7, 11, -1);



可变参数函数的原型声明格式为:

type VAFunction(type arg1, type arg2, … );

参数可以分为两部分:个数确定的固定参数和个数可变的可选参数。函数至少需要一个固定参数,固定参数的声明和普通函数一样;可选参数由于个数不确定,声明时用"…"表示。固定参数和可选参数公同构成一个函数的参数列表。

借助上面这个简单的例2,来看看各个va_xxx的作用。

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()之内。

三、 编译器如何实现va

例2中调用SqSum(7, 2, 7, 11, -1)来求7, 2, 7, 11的平方和,-1是结束标志。

简单地说,va函数的实现就是对参数指针的使用和控制。


typedef char *  va_list;  // x86平台下va_list的定义



函数的固定参数部分,可以直接从函数定义时的参数名获得;对于可选参数部分,先将指针指向第一个可选参数,然后依次后移指针,根据与结束标志的比较来判断是否已经获得全部参数。因此,va函数中结束标志必须事先约定好,否则,指针会指向无效的内存地址,导致出错。

这里,移动指针使其指向下一个参数,那么移动指针时的偏移量是多少呢,没有具体答案,因为这里涉及到内存对齐(alignment)问题,内存对齐跟具体使用的硬件平台有密切关系,比如大家熟知的32位x86平台规定所有的变量地址必须是4的倍数(sizeof(int) = 4)。va机制中用宏_INTSIZEOF(n)来解决这个问题,没有这些宏,va的可移植性无从谈起。

首先介绍宏_INTSIZEOF(n),它求出变量占用内存空间的大小,是va的实现的基础。


#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 )                           // 将指针置为无效



下表是针对函数int TestFunc(int n1, int n2, int n3, …)

参数传递时的内存堆栈情况。(C编译器默认的参数传递方式是__cdecl。)

对该函数的调用为int result = TestFunc(a, b, c, d. e); 其中e为结束标志。


从上图中可以很清楚地看出va_xxx宏如此编写的原因。

1. va_start。为了得到第一个可选参数的地址,我们有三种办法可以做到:

A) = &n3 + _INTSIZEOF(n3)

// 最后一个固定参数的地址 + 该参数占用内存的大小

B) = &n2 + _INTSIZEOF(n3) + _INTSIZEOF(n2)

// 中间某个固定参数的地址 + 该参数之后所有固定参数占用的内存大小之和

C) = &n1 + _INTSIZEOF(n3) + _INTSIZEOF(n2) + _INTSIZEOF(n1)

// 第一个固定参数的地址 + 所有固定参数占用的内存大小之和

从编译器实现角度来看,方法B),方法C)为了求出地址,编译器还需知道有多少个固定参数,以及它们的大小,没有把问题分解到最简单,所以不是很聪明的途径,不予采纳;相对来说,方法A)中运算的两个值则完全可以确定。va_start()正是采用A)方法,接受最后一个固定参数。调用va_start ()的结果总是使指针指向下一个参数的地址,并把它作为第一个可选参数。在含多个固定参数的函数中,调用va_start()时,如果不是用最后一个固定参数,对于编译器来说,可选参数的个数已经增加,将给程序带来一些意想不到的错误。(当然如果你认为自己对指针已经知根知底,游刃有余,那么,怎么用就随你,你甚至可以用它完成一些很优秀(高效)的代码,但是,这样会大大降低代码的可读性。)

注意:宏va_start是对参数的地址进行操作的,要求参数地址必须是有效的。一些地址无效的类型不能当作固定参数类型。比如:寄存器类型,它的地址不是有效的内存地址值;数组和函数也不允许,他们的长度是个问题。因此,这些类型时不能作为va函数的参数的。

2. va_arg身兼二职:返回当前参数,并使参数指针指向下一个参数。

初看va_arg宏定义很别扭,如果把它拆成两个语句,可以很清楚地看出它完成的两个职责。


#define va_arg(ap,t)   ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址
// 将( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )拆成:
/* 指针ap指向下一个参数的地址 */
1. ap += _INTSIZEOF(t);        // 当前,ap已经指向下一个参数了
/* ap减去当前参数的大小得到当前参数的地址,再强制类型转换后返回它的值 */
2. return *(t *)( ap - _INTSIZEOF(t)) 



回想到printf/scanf系列函数的%d %s之类的格式化指令,我们不难理解这些它们的用途了- 明示参数强制转换的类型。

(注:printf/scanf没有使用va_xxx来实现,但原理是一致的。)

3.va_end很简单,仅仅是把指针作废而已。

#define va_end(ap) (ap = (va_list)0) // x86平台

四、 简洁、灵活,也有危险

从va的实现可以看出,指针的合理运用,把C语言简洁、灵活的特性表现得淋漓尽致,叫人不得不佩服C的强大和高效。不可否认的是,给编程人员太多*空间必然使程序的安全性降低。va中,为了得到所有传递给函数的参数,需要用va_arg依次遍历。其中存在两个隐患:

1)如何确定参数的类型。

va_arg在类型检查方面与其说非常灵活,不如说是很不负责,因为是强制类型转换,va_arg都把当前指针所指向的内容强制转换到指定类型;

2)结束标志。如果没有结束标志的判断,va将按默认类型依次返回内存中的内容,直到访问到非法内存而出错退出。例2中SqSum()求的是自然数的平方和,所以我把负数和0作为它的结束标志。例如scanf把接收到的回车符作为结束标志,大家熟知的printf()对字符串的处理用'/0'作为结束标志,无法想象C中的字符串如果没有'/0', 代码将会是怎样一番情景,估计那时最流行的可能是字符数组,或者是malloc/free。

允许对内存的随意访问,会留给不怀好意者留下攻击的可能。当处理cracker精心设计好的一串字符串后,程序将跳转到一些恶意代码区域执行,以使cracker达到其攻击目的。(常见的exploit攻击)所以,必需禁止对内存的随意访问和严格控制内存访问边界。 五、 Unix System V兼容方式的va声明

上面介绍可变参数函数的声明是采用ANSI标准的,Unix System V兼容方式的声明有一点点区别,它增加了两个宏:va_alist,va_dcl。而且它们不是定义在stdarg.h中,而是varargs.h中。 stdarg.h是ANSI标准的;varargs.h仅仅是为了能与以前的程序保持兼容而出现的,现在的编程中不推荐使用。

va_alist:函数声明/定义时出现在函数头,用以接受参数列表。

va_dcl:对va_alist的声明,其后无需跟分号";"

va_start的定义也不相同。因为System V可变参数函数声明不区分固定参数和可选参数,直接对参数列表操作。所以va_start()不是va_start(ap,v),而是简化为va_start(ap)。其中,ap是va_list型的参数指针。

Unix System V兼容方式下函数的声明形式:

type VAFunction(va_alist)

va_dcl // 这里无需分号

{

// 函数体内同ANSI标准

}

// 例3:猜测execl的实现(Unix System V兼容方式),摘自SUS V2


#include 

#define MAXARGS    100
/ * execl(file, arg1, arg2, ..., (char *)0); */

execl(va_alist)
va_dcl
{
    va_list ap;
    char *file;
    char *args[MAXARGS];
    int argno = 0;

    va_start(ap);
    file = va_arg(ap, char *);
    while ((args[argno++] = va_arg(ap, char *)) != (char *)0)
        ;
    va_end(ap);
    return execv(file, args);
}



六、 扩展与思考

个数可变参数在声明时只需"..."即可;但是,我们在接受这些参数时不能"..."。va函数实现的关键就是如何得到参数列表中可选参数,包括参数的值和类型。以上的所有实现都是基于来自stdarg.h的va_xxx的宏定义。 <思考>能不能不借助于va_xxx,自己实现VA呢?,我想到的方法是汇编。在C中,我们当然就用C的嵌入汇编来实现,这应该是可以做得到的。至于能做到什么程度,稳定性和效率怎么样,主要要看你对内存和指针的控制了。

参考资料

1.IEEE和OpenGroup联合开发的Single Unix specification Ver3;BR>
2.Linux man手册;

3.x86汇编,还有一些安全编码方面的资料。

---------------------------------------------------------------------------------------------------------------------
[转帖]对C/C++可变参数表的深层探索

C/C++语言有一个不同于其它语言的特性,即其支持可变参数,典型的函数如printf、scanf等可以接受数量不定的参数。如:
  printf ( "I love you" );
  printf ( "%d", a );
  printf ( "%d,%d", a, b );
  第一、二、三个printf分别接受1、2、3个参数,让我们看看printf函数的原型:
  int printf ( const char *format, ... );
  从函数原型可以看出,其除了接收一个固定的参数format以外,后面的参数用"…"表示。在C/C++语言中,"…"表示可以接受不定数量的参数,理论上来讲,可以是0或0以上的n个参数。
  本文将对C/C++可变参数表的使用方法及C/C++支持可变参数表的深层机理进行探索。
 
  一. 可变参数表的用法
  1、相关宏
  标准C/C++包含头文件stdarg.h,该头文件中定义了如下三个宏:
void va_start ( va_list arg_ptr, prev_param ); /* ANSI version */
type va_arg ( va_list arg_ptr, type );
void va_end ( va_list arg_ptr ); 
  在这些宏中,va就是variable argument(可变参数)的意思;arg_ptr是指向可变参数表的指针;prev_param则指可变参数表的前一个固定参数;type为可变参数的类型。va_list也是一个宏,其定义为typedef char * va_list,实质上是一 char型指针。char型指针的特点是++、--操作对其作用的结果是增1和减1(因为sizeof(char)为1),与之不同的是int等其它类型指针的++、--操作对其作用的结果是增sizeof(type)或减sizeof(type),而且sizeof (type)大于1。
  通过va_start宏我们可以取得可变参数表的首指针,这个宏的定义为:
#define va_start ( ap, v ) ( ap = (va_list)&v + _INTSIZEOF(v) )
  显而易见,其含义为将最后那个固定参数的地址加上可变参数对其的偏移后赋值给ap,这样ap就是可变参数表的首地址。其中的_INTSIZEOF宏定义为:
#define _INTSIZEOF(n) ((sizeof ( n ) + sizeof ( int ) - 1 ) & ~( sizeof( int ) - 1 ) )
  va_arg宏的意思则指取出当前arg_ptr所指的可变参数并将ap指针指向下一可变参数,其原型为:
#define va_arg(list, mode) ((mode *)(list =(char *) ((((int)list + (__builtin_alignof(mode)<=4?3:7)) &(__builtin_alignof(mode)<=4?-4:-8))+sizeof(mode))))[-1]
  对这个宏的具体含义我们将在后面深入讨论。
  而va_end宏被用来结束可变参数的获取,其定义为:
#define va_end ( list )
  可以看出,va_end ( list )实际上被定义为空,没有任何真实对应的代码,用于代码对称,与va_start对应;另外,它还可能发挥代码的"自注释"作用。所谓代码的"自注释",指的是代码能自己注释自己。
  下面我们以具体的例子来说明以上三个宏的使用方法。
  2、一个简单的例子
  #include <stdarg.h>
  /* 函数名:max
  * 功能:返回n个整数中的最大值
  * 参数:num:整数的个数 ...:num个输入的整数
  * 返回值:求得的最大整数
  */
  int max ( int num, ... )
  {
   int m = -0x7FFFFFFF; /* 32系统中最小的整数 */
   va_list ap;
   va_start ( ap, num );
   for ( int i= 0; i< num; i++ )
   {
    int t = va_arg (ap, int);
    if ( t > m )
    {
     m = t;
    }
   }
   va_end (ap);
   return m;
  }
  /* 主函数调用max */
  int main ( int argc, char* argv[] )
  {
   int n = max ( 5, 5, 6 ,3 ,8 ,5); /* 求5个整数中的最大值 */
   cout << n;
   return 0;
  }
  函数max中首先定义了可变参数表指针ap,而后通过va_start ( ap, num )取得了参数表首地址(赋给了ap),其后的for循环则用来遍历可变参数表。这种遍历方式与我们在数据结构教材中经常看到的遍历方式是类似的。
  函数max看起来简洁明了,但是实际上printf的实现却远比这复杂。max函数之所以看起来简单,是因为:
  (1) max函数可变参数表的长度是已知的,通过num参数传入;
  (2) max函数可变参数表中参数的类型是已知的,都为int型。
  而printf函数则没有这么幸运。首先,printf函数可变参数的个数不能轻易的得到,而可变参数的类型也不是固定的,需由格式字符串进行识别(由%f、%d、%s等确定),因此则涉及到可变参数表的更复杂应用。
  下面我们以实例来分析可变参数表的高级应用。
 
  二. 高级应用
  下面这个程序是我们为某嵌入式系统(该系统中CPU的字长为16位)编写的在屏幕上显示格式字符串的函数DrawText,它的用法类似于 int printf ( const char *format, ... )函数,但其输出的目标为嵌入式系统的液晶显示屏幕(LED)。
  ///////////////////////////////////////////////////////////////////////////////
  // 函数名称: DrawText
  // 功能说明: 在显示屏上绘制文字
  // 参数说明: xPos ---横坐标的位置 [0 .. 30]
  // yPos ---纵坐标的位置 [0 .. 64]
  // ... 可以同数字一起显示,需设置标志(%d、%l、%x、%s)
  ///////////////////////////////////////////////////////////////////////////////
  extern void DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )
  {
   BYTE lpData[100]; //缓冲区
   BYTE byIndex;
   BYTE byLen;
   DWORD dwTemp;
   WORD wTemp;
   int i;
   va_list lpParam;
   memset( lpData, 0, 100);
   byLen = strlen( lpStr );
   byIndex = 0;
   va_start ( lpParam, lpStr );
   for ( i = 0; i < byLen; i++ )
   {
    if( lpStr[i] != ’%’ ) //不是格式符开始
    {
     lpData[byIndex++] = lpStr[i];
    }
    else
    {
     switch (lpStr[i+1])
     {
      //整型
      case ’d’:
      case ’D’:
       wTemp = va_arg ( lpParam, int );
       byIndex += IntToStr( lpData+byIndex, (DWORD)wTemp );
       i++;
       break;
      //长整型
      case ’l’:
      case ’L’:
       dwTemp = va_arg ( lpParam, long );
       byIndex += IntToStr ( lpData+byIndex, (DWORD)dwTemp );
       i++;
       break;
      //16进制(长整型)
      case ’x’:
      case ’X’:
       dwTemp = va_arg ( lpParam, long );
       byIndex += HexToStr ( lpData+byIndex, (DWORD)dwTemp );
       i++;
       break;
      default:
       lpData[byIndex++] = lpStr[i];
       break;
     }
    }
   }
   va_end ( lpParam );
   lpData[byIndex] = ’/0’;
   DisplayString ( xPos, yPos, lpData, TRUE); //在屏幕上显示字符串lpData
  }
  在这个函数中,需通过对传入的格式字符串(首地址为lpStr)进行识别来获知可变参数个数及各个可变参数的类型,具体实现体现在for循环中。譬如,在识别为%d后,做的是va_arg ( lpParam, int ),而获知为%l和%x后则进行的是va_arg ( lpParam,  long )。格式字符串识别完成后,可变参数也就处理完了。
  在项目的最初,我们一直苦于不能找到一个好的办法来混合输出字符串和数字,我们采用了分别显示数字和字符串的方法,并分别指定坐标,程序条理被破坏。而且,在混合显示的时候,要给各类数据分别人工计算坐标,我们感觉头疼不已。以前的函数为:
  //显示字符串
  showString ( BYTE xPos, BYTE yPos, LPBYTE lpStr )
  //显示数字
  showNum ( BYTE xPos, BYTE yPos, int num )
  //以16进制方式显示数字
  showHexNum ( BYTE xPos, BYTE yPos, int num )
  最终,我们用DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )函数代替了原先所有的输出函数,程序得到了简化。就这样,兄弟们用得爽翻了。
 
  三. 运行机制探索
  通过第2节我们学会了可变参数表的使用方法,相信喜欢抛根问底的读者还不甘心,必然想知道如下问题:
  (1)为什么按照第2节的做法就可以获得可变参数并对其进行操作?
  (2)C/C++在底层究竟是依靠什么来对这一语法进行支持的,为什么其它语言就不能提供可变参数表呢?
  我们带着这些疑问来一步步进行摸索。
  3.1 调用机制反汇编
  反汇编是研究语法深层特性的终极良策,先来看看2.2节例子中主函数进行max ( 5, 5, 6 ,3 ,8 ,5)调用时的反汇编:
  1. 004010C8 push 5
  2. 004010CA push 8
  3. 004010CC push 3
  4. 004010CE push 6
  5. 004010D0 push 5
  6. 004010D2 push 5
  7. 004010D4 call @ILT+5(max) (0040100a)
  从上述反汇编代码中我们可以看出,C/C++函数调用的过程中:
  第一步:将参数从右向左入栈(第1~6行);
  第二步:调用call指令进行跳转(第7行)。
  这两步包含了深刻的含义,它说明C/C++默认的调用方式为由调用者管理参数入栈的操作,且入栈的顺序为从右至左,这种调用方式称为_cdecl调用。x86系统的入栈方向为从高地址到低地址,故第1至n个参数被放在了地址递增的堆栈内。在被调用函数内部,读取这些堆栈的内容就可获得各个参数的值,让我们反汇编到max函数的内部:
  int max ( int num, ...)
  {
  1. 00401020 push ebp
  2. 00401021 mov ebp,esp
  3. 00401023 sub esp,50h
  4. 00401026 push ebx
  5. 00401027 push esi
  6. 00401028 push edi
  7. 00401029 lea edi,[ebp-50h]
  8. 0040102C mov ecx,14h
  9. 00401031 mov eax,0CCCCCCCCh
  10. 00401036 rep stos dword ptr [edi]
  va_list ap;
  int m = -0x7FFFFFFF; /* 32系统中最小的整数 */
  11. 00401038 mov dword ptr [ebp-8],80000001h
  va_start ( ap, num );
  12. 0040103F lea eax,[ebp+0Ch]
  13. 00401042 mov dword ptr [ebp-4],eax
  for ( int i= 0; i< num; i++ )
  14. 00401045 mov dword ptr [ebp-0Ch],0
  15. 0040104C jmp max+37h (00401057)
  16. 0040104E mov ecx,dword ptr [ebp-0Ch]
  17. 00401051 add ecx,1
  18. 00401054 mov dword ptr [ebp-0Ch],ecx
  19. 00401057 mov edx,dword ptr [ebp-0Ch]
  20. 0040105A cmp edx,dword ptr [ebp+8]
  21. 0040105D jge max+61h (00401081)
  {
   int t= va_arg (ap, int);
   22. 0040105F mov eax,dword ptr [ebp-4]
   23. 00401062 add eax,4
   24. 00401065 mov dword ptr [ebp-4],eax
   25. 00401068 mov ecx,dword ptr [ebp-4]
   26. 0040106B mov edx,dword ptr [ecx-4]
   27. 0040106E mov dword ptr [t],edx
   if ( t > m )
    28. 00401071 mov eax,dword ptr [t]
    29. 00401074 cmp eax,dword ptr [ebp-8]
    30. 00401077 jle max+5Fh (0040107f)
    m = t;
    31. 00401079 mov ecx,dword ptr [t]
    32. 0040107C mov dword ptr [ebp-8],ecx
   }
   33. 0040107F jmp max+2Eh (0040104e)
   va_end (ap);
   34. 00401081 mov dword ptr [ebp-4],0
   return m;
   35. 00401088 mov eax,dword ptr [ebp-8]
  }
  36. 0040108B pop edi
  37. 0040108C pop esi
  38. 0040108D pop ebx
  39. 0040108E mov esp,ebp
  40. 00401090 pop ebp
  41. 00401091 ret
  分析上述反汇编代码,对于一个真正的程序员而言,将是一种很大的享受;而对于初学者,也将使其受益良多。所以请一定要赖着头皮认真研究,千万不要被吓倒!
  行1~10进行执行函数内代码的准备工作,保存现场。第2行对堆栈进行移动;第3行则意味着max函数为其内部局部变量准备的堆栈空间为50h字节;第11行表示把变量n的内存空间安排在了函数内部局部栈底减8的位置(占用4个字节)。
  第12~13行非常关键,对应着va_start ( ap, num ),这两行将第一个可变参数的地址赋值给了指针ap。另外,从第12行可以看出num的地址为ebp+0Ch;从第13行可以看出ap被分配在函数内部局部栈底减4的位置上(占用4个字节)。
  第22~27行最为关键,对应着va_arg (ap, int)。其中,22~24行的作用为将ap指向下一可变参数(可变参数的地址间隔为4个字节,从add eax,4可以看出);25~27行则取当前可变参数的值赋给变量t。这段反汇编很奇怪,它先移动可变参数指针,再在赋值指令里面回过头来取先前的参数值赋给t(从mov edx,dword ptr [ecx-4]语句可以看出)。Visual C++同学玩得有意思,不知道碰见同样的情况Visual Basic等其它同学怎么玩?
  第36~41行恢复现场和堆栈地址,执行函数返回操作。
  痛苦的反汇编之旅差不多结束了,看了这段反汇编我们总算弄明白了可变参数的存放位置以及它们被读取的方式,顿觉全省轻松!
  2、特殊的调用约定
  除此之外,我们需要了解C/C++函数调用对参数占用空间的一些特殊约定,因为在_cdecl调用协议中,有些变量类型是按照其它变量的尺寸入栈的。
  例如,字符型变量将被自动扩展为一个字的空间,因为入栈操作针对的是一个字。
  参数n实际占用的空间为( ( sizeof(n) + sizeof(int) - 1 ) & ~( sizeof(int) - 1 ) ),这就是第2.1节_INTSIZEOF(v)宏的来历!
  既然如此,前面给出的va_arg ( list, mode )宏为什么玩这么大的飞机就很清楚了。这个问题就留个读者您来分析.

---------------------------------------------------------------------------------------------------------------------
C语言参数可变函数的设计
湖州市东风丝织厂电脑室(313000) 沈桂林
C语言程序中大多数函数的参数数量是固定的,但在编制较大的C语言程序时,往往需要函
数的参数数量是可变的。C语言的许多系统函数,如printf()、execl()等,参数均是可变的
。使用参数可变函数,往往能缩短编码,提高效率,增强编程的灵活性。尽管C提供了可变参
数的功能,但由于资料描述过于简略,用户往往不得要领,事实上,如果用户了解了C函数的参
数函数是不难的。
一、参数的传递
假设有如下一个C程序:
main()
{……
f(v1, v2 v3) ;
……
}
f (f1, f2, f3)
{……}
函数调用f(v1,v2,v3)可等价如下的汇编语句(假设每个参数占用4个字节):
push v3
push v2
push v1
call_f
add sp,12
@@03L13100.GIF;图1@@
由于调用了函数f ()后再恢复sp的值 (而不是由f ()恢复sp) ,所以定义f()时无论用
几个变量,f()均能正确返回并继续执行下去。函数f()的执行过程是:1.初始化栈,2.为临时
变量在栈顶分配空间,3.执行f()语句,等等。在f()初始化栈后,其栈情况如图1所示。变量
v1、v2、v3分别被放到bp+8、bp+12、bp+16的双字中。f()也将这三个双字作为形参f1、f
2、f3的分配空间(如图1所示)。因为地址连续,函数中只要有第一个参数,第二、第三个参
数的地址就可依次求得。假设dptr是指向字符的指针,则:
cptr= (char *)&f1 / * cptr指向f1 * /
cptr+=sizeof (f1) / * cptr指向f2 * /
cptr+=sizeof (f2) / * cptr指向f3 * /
三、参数的获取
可变参数函数至少要定义一个参数,以便用这个参数求出存放参数的起始地址,这个参
数的类型是无关紧要的。程序p1.c包含一个显示错误消息的函数cerror () 。对于大的程
序 ,错误消息格式多样,并且在显示消息时还要做些其他工作。第7、8二行调用分别使用了
6个和2个参数调用。cerror ()用变量v求出地址cptr,从cptr开始放置了格式串所需的参数
,将该地址直接传给vprintf () 。
如果函数需要参数的值,则需要根据变量的类型移动指向变量的指针。因此参数的类型
必须是可知的。在程序p2.c中,min (n)返回n个整数的最小值,因为参数均为整数,min (n)
中的cptr定义为指向整数的指针,以方便移动。对于串型参数,调用时压入指向串的指针值
。程序p3.c以不同的参数类型说明了对参数的引用方法。函数fly ()求出飞机从起点到终
点的总航程。地址用串,航程用双精度表示。最后一个参数用0.0表示。第11句将cptr转化
为指向double的指针,求出double的值并移过该double,第13句将cptr转变为字符指针的指
针,赋值给ecity并下移cptr。
三、结论
总之,使用可变参数的过程可概括为:
〈1〉定义一个指针;
〈2〉将起始参数地址赋给该指针;
〈3〉用指针求参数值;
〈4〉下移指针。
按此方法编程,指针类型转换及指针下移还是有点繁琐。可定义几个宏,如程序va.h所
示。利用这几个宏,可使程序更为清晰可读。只要说明参数类型,就可求出参数并下移指针
。比较C语言中已经说明的方法更加实用。用va.h可将p3.c改成p4.c 。
以上p1.c 、p2.c、p3.c、p4.c程序均在XENIXC及Turbo C2.0调试通过。
1 /*程序名 :p1.c */
2 #include
3 int i1=1,i2=2;
4 char *s1="message1",*s2="message2";
5 main()
6 {
7 cerror("f1()","%d %s %d %s ",i1,s1,i2,s2);
8 cerror("main()","no args");
9 }
10 cerror(fname,fmt,v)
11 char *fname,*fmt;
12 {
13 char *cptr=(char *)&v;
14 printf("%s : ",fname);
15 vprintf(fmt,cptr);
16 printf("/n");
17 }
1 /* 程序名 :p2.c */
2 #include
3 main()
4 {
5 printf("min=%d/n",min(3,3,2,10));
6 printf("min=%d/n",min(5,9,,8,7,6,4));
7 }
8 min(n)
9 {
10 int *cptr=&n,m;
11 cptr++;
12 m=*cptr++;
13 while (--n>0)
14 {if (m>*cptr) m=*cptr;
15 cptr++;
16 }
17 return m;
18 }
1 /* 程序名 :p3.c */
2 #include
3 fly(scity,miles,ecity,s)
4 char *scity,*ecity,s;
5 double miles;
6 {
7 char *cptr;
8 cptr=&s;
9 while (*((double *)cptr)l=0.0)
10 {
11 miles+*((double *)cptr)++;
12 /* equal: miles+=*((double *)cptr);((double *)cptr)++;*/
13 ecity=*((char **)cptr)++;
14 }
15 printf("From %s Total %8.2f miles/n",scity,ecity,miles);
16 }
17 main()
18 {
19 fly("New York",800.0,"Toronto",500.0,"Chicago",0.0);
20 fly("New York",1000.0,"Chicago",1000.0,"Denver",1000.0,"Los Angles",
0.0);
21 }
1 /* program p4.c */
2 #inclue
3 #include"va.h"
4 fly(scity,miles,ecity,s)
5 char *scity,*ecity;
6 double miles;
7 {
8 void *cptr;
9 cptr=va_start(s);
10 while(va_arg(cptr,double)!=0.0)
11 {
12 miles+=va_argpp(cptr,double);
13 ecity=va_argpp(cptr,char *);
14 }
15 printf("From %s to %s Total %8.2f miles/n",scity,ecity,miles);
16 }
17 main()
18 {
19 fly("New York",800.0,"Toronto",500.o"Chicago",0.0);
20 fly("New York",1000.0,"Chicago:,1000.0,"Denver",1000.0,"Los Angles",
0.0);
21 }
22
1 /* program :va.h */
2 #define va_start(vptr) (char *)&vptr /* 指针初始化 */
3 #define va_arg(vptr,mode) *((mode *)vptr) /*求出类型为moder的值 */
4 #define va_argpp(vptr,mode *)vptr)++ /*求出类型为mode的值,下移指针*/
5 #define va_pp(vptr,mode)(mode *)vptr++ /*下移类型为mode的指针*/


---------------------------------------------------------------------------------------------------------------------
 C语言中可变参数的用法

                                       Copyright by kevintz

    我们在C语言编程中会遇到一些参数个数可变的函数,例如printf()
这个函数,它的定义是这样的:
    int printf( const char* format, ...);
    它除了有一个参数format固定以外,后面跟的参数的个数和类型是
可变的,例如我们可以有以下不同的调用方法:
    printf("%d",i);
    printf("%s",s);
    printf("the number is %d ,string is:%s", i, s);
究竟如何写可变参数的C函数以及这些可变参数的函数编译器是如何实
现的呢?本文就这个问题进行一些探讨,希望能对大家有些帮助.会C++的
网友知道这些问题在C++里不存在,因为C++具有多态性.但C++是C的一个
超集,以下的技术也可以用于C++的程序中.限于本人的水平,文中如果有
不当之处,请大家指正.

              (一)写一个简单的可变参数的C函数

    下面我们来探讨如何写一个简单的可变参数的C函数.写可变参数的
C函数要在程序中用到以下这些宏:
    void va_start( va_list arg_ptr, prev_param );

    type va_arg( va_list arg_ptr, type );

    void va_end( va_list arg_ptr );
    va在这里是variable-argument(可变参数)的意思.
    这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个
头文件.下面我们写一个简单的可变参数的函数,改函数至少有一个整数
参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值.
    void simple_va_fun(int i, ...)
    {
        va_list arg_ptr;
        int j=0;
         
        va_start(arg_ptr, i);
        j=va_arg(arg_ptr, int);
        va_end(arg_ptr);
        printf("%d %d/n", i, j);
        return;
    }
    我们可以在我们的头文件中这样声明我们的函数:
    extern void simple_va_fun(int i, ...);
    我们在程序中可以这样调用:
    simple_va_fun(100);
    simple_va_fun(100,200);
    从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:
    1)首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变
      量是指向参数的指针.
    2)然后用va_start宏初始化变量arg_ptr,这个宏的第二个参数是第
      一个可变参数的前一个参数,是一个固定的参数.
    3)然后用va_arg返回可变的参数,并赋值给整数j. va_arg的第二个
      参数是你要返回的参数的类型,这里是int型.
    4)最后用va_end宏结束可变参数的获取.然后你就可以在函数里使
      用第二个参数了.如果函数有多个可变参数的,依次调用va_arg获
      取各个参数.
    如果我们用下面三种方法调用的话,都是合法的,但结果却不一样:
    1)simple_va_fun(100);
      结果是:100 -123456789(会变的值)
    2)simple_va_fun(100,200);
      结果是:100 200
    3)simple_va_fun(100,200,300);
      结果是:100 200
    我们看到第一种调用有错误,第二种调用正确,第三种调用尽管结果
正确,但和我们函数最初的设计有冲突.下面一节我们探讨出现这些结果
的原因和可变参数在编译器中是如何处理的.
 
              (二)可变参数在编译器中的处理

    我们知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,
由于1)硬件平台的不同 2)编译器的不同,所以定义的宏也有所不同,下
面以VC++中stdarg.h里x86平台的宏定义摘录如下('/'号表示折行):

typedef char * va_list;

#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 )

定义_INTSIZEOF(n)主要是为了某些需要内存的对齐的系统.C语言的函
数是从右向左压入堆栈的,图(1)是函数的参数在堆栈中的分布位置.我
们看到va_list被定义成char*,有一些平台或操作系统定义为void*.再
看va_start的定义,定义为&v+_INTSIZEOF(v),而&v是固定参数在堆栈的
地址,所以我们运行va_start(ap, v)以后,ap指向第一个可变参数在堆
栈的地址,如图:

  高地址
|-----------------------------|
|.......                      |
|-----------------------------|
|第n个参数(第一个可变参数)    |
|----------------------------|<--va_start后ap指向
|第n-1个参数(最后一个固定参数)|
|-----------------------------|<-- &v
|函数返回地址 |
|----------------------------|
低地址

图( 1 )

然后,我们用va_arg()取得类型t的可变参数值,以上例为int型为例,我
们看一下va_arg取int型的返回值:
j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );
首先ap+=sizeof(int),已经指向下一个参数的地址了.然后返回
ap-sizeof(int)的int*指针,这正是第一个可变参数在堆栈里的地址
(图2).然后用*取得这个地址的内容(参数值)赋给j.

高地址
|-----------------------------|
|....... |
|-----------------------------|<--va_arg后ap指向
|第n个参数(第一个可变参数) |
|-----------------------------|<--va_start后ap指向
|第n-1个参数(最后一个固定参数)|
|-----------------------------|<-- &v
|函数返回地址 |
|----------------------------|
低地址
图( 2 )

最后要说的是va_end宏的意思,x86平台定义为ap=(char*)0;使ap不再
指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不
会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的.
在这里大家要注意一个问题:由于参数的地址用于va_start宏,所
以参数不能声明为寄存器变量或作为函数或数组类型.
关于va_start, va_arg, va_end的描述就是这些了,我们要注意的
是不同的操作系统和硬件平台的定义有些不同,但原理却是相似的.

(三)可变参数在编程中要注意的问题

因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,
可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能
地识别不同参数的个数和类型.
有人会问:那么printf中不是实现了智能识别参数吗?那是因为函数
printf是从固定参数format字符串来分析出参数的类型,再调用va_arg
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
过在自己的程序里作判断来实现的.
另外有一个问题,因为编译器对可变参数的函数的原型检查不够严
格,对编程查错不利.如果simple_va_fun()改为:
void simple_va_fun(int i, ...)
{
va_list arg_ptr;
char *s=NULL;

va_start(arg_ptr, i);
s=va_arg(arg_ptr, char*);
va_end(arg_ptr);
printf("%d %s/n", i, s);
return;
}
可变参数为char*型,当我们忘记用两个参数来调用该函数时,就会出现
core dump(Unix) 或者页面非法的错误(window平台).但也有可能不出
错,但错误却是难以发现,不利于我们写出高质量的程序.
以下提一下va系列宏的兼容性.
System V Unix把va_start定义为只有一个参数的宏:
va_start(va_list arg_ptr);
而ANSI C则定义为:
va_start(va_list arg_ptr, prev_param);
如果我们要用system V的定义,应该用vararg.h头文件中所定义的
宏,ANSI C的宏跟system V的宏是不兼容的,我们一般都用ANSI C,所以
用ANSI C的定义就够了,也便于程序的移植.


小结:
可变参数的函数原理其实很简单,而va系列是以宏定义来定义的,实
现跟堆栈相关.我们写一个可变函数的C函数时,有利也有弊,所以在不必
要的场合,我们无需用到可变参数.如果在C++里,我们应该利用C++的多
态性来实现可变参数的功能,尽量避免用C语言的方式来实现.

写这篇文章时,适逢感冒,多得有她的关怀,谨把这篇文章献给她...


kevintz
2000-4-26 23:23




-- 
黄昏里,那一抹夕阳又向西...... 

---------------------------------------------------------------------------------------------------------------------
水滴石穿C语言之可变参数问题
2004-12-12 12:06 作者: 楚云风 出处: 天极网 责任编辑:方舟
  概述

  C语言中有一种长度不确定的参数,形如:"…",它主要用在参数个数不确定的函数中,我们最容易想到的例子是printf函数。

  原型:

int printf( const char *format [, argument]... );

  使用例:

printf("Enjoy yourself everyday!/n");
printf("The value is %d!/n", value);

  这种可变参数可以说是C语言一个比较难理解的部分,这里会由几个问题引发一些对它的分析。

  注意:在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任意数量的函数参数。

  问题:printf的实现

  请问,如何自己实现printf函数,如何处理其中的可变参数问题? 答案与分析:

  在标准C语言中定义了一个头文件<stdarg.h>专门用来对付可变参数列表,它包含了一组宏,和一个va_list的typedef声明。一个典型实现如下:

typedef char* va_list;
#define va_start(list) list = (char*)&va_alist
#define va_end(list)
#define va_arg(list, mode)/
((mode*) (list += sizeof(mode)))[-1]
自己实现printf:
#include <stdarg.h>
int printf(char* format, …)
{
va_list ap;
va_start(ap, format);
int n = vprintf(format, ap);
va_end(ap);
return n;
}

  问题:运行时才确定的参数

  有没有办法写一个函数,这个函数参数的具体形式可以在运行时才确定?

  答案与分析:

  目前没有"正规"的解决办法,不过独门偏方倒是有一个,因为有一个函数已经给我们做出了这方面的榜样,那就是main(),它的原型是:

int main(int argc,char *argv[]);

  函数的参数是argc和argv。

  深入想一下,"只能在运行时确定参数形式",也就是说你没办法从声明中看到所接受的参数,也即是参数根本就没有固定的形式。常用的办法是你可以通过定义一个void *类型的参数,用它来指向实际的参数区,然后在函数中根据根据需要任意解释它们的含义。这就是main函数中argv的含义,而argc,则用来表明实际的参数个数,这为我们使用提供了进一步的方便,当然,这个参数不是必需的。

  虽然参数没有固定形式,但我们必然要在函数中解析参数的意义,因此,理所当然会有一个要求,就是调用者和被调者之间要对参数区内容的格式,大小,有效性等所有方面达成一致,否则南辕北辙各说各话就惨了。

  问题:可变长参数的传递

  有时候,需要编写一个函数,将它的可变长参数直接传递给另外的函数,请问,这个要求能否实现?

  答案与分析:

  目前,你尚无办法直接做到这一点,但是我们可以迂回前进,首先,我们定义被调用函数的参数为va_list类型,同时在调用函数中将可变长参数列表转换为va_list,这样就可以进行变长参数的传递了。看如下所示:

void subfunc (char *fmt, va_list argp)
{
...
arg = va_arg (fmt, argp); /* 从argp中逐一取出所要的参数 */
...
}

void mainfunc (char *fmt, ...)
{
va_list argp;
va_start (argp, fmt); /* 将可变长参数转换为va_list */
subfunc (fmt, argp); /* 将va_list传递给子函数 */
va_end (argp);
...
}

  问题:可变长参数中类型为函数指针

  我想使用va_arg来提取出可变长参数中类型为函数指针的参数,结果却总是不正确,为什么?

  答案与分析:

  这个与va_arg的实现有关。一个简单的、演示版的va_arg实现如下:

#define va_arg(argp, type) /
(*(type *)(((argp) += sizeof(type)) - sizeof(type)))

  其中,argp的类型是char *。

  如果你想用va_arg从可变参数列表中提取出函数指针类型的参数,例如

int (*)(),则va_arg(argp, int (*)())被扩展为:
(*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))

  显然,(int (*)() *)是无意义的。

  解决这个问题的办法是将函数指针用typedef定义成一个独立的数据类型,例如:

typedef int (*funcptr)();

  这时候再调用va_arg(argp, funcptr)将被扩展为:

(* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))

  这样就可以通过编译检查了。

  问题:可变长参数的获取

  有这样一个具有可变长参数的函数,其中有下列代码用来获取类型为float的实参:

va_arg (argp, float);

  这样做可以吗?

  答案与分析:

  不可以。在可变长参数中,应用的是"加宽"原则。也就是float类型被扩展成double;char, short被扩展成int。因此,如果你要去可变长参数列表中原来为float类型的参数,需要用va_arg(argp, double)。对char和short类型的则用va_arg(argp, int)。

  问题:定义可变长参数的一个限制

  为什么我的编译器不允许我定义如下的函数,也就是可变长参数,但是没有任何的固定参数?

int f (...)
{
...
}

  答案与分析:

  不可以。这是ANSI C 所要求的,你至少得定义一个固定参数。

  这个参数将被传递给va_start(),然后用va_arg()和va_end()来确定所有实际调用时可变长参数的类型和值。 

---------------------------------------------------------------------------------------------------------------------
水滴石穿C语言之可变参数问题
网窝网版权所有webwoo.net!这里可以修改成你网站的信息
作者:不详 文章来源:互联网 点击数:52  更新时间:2007-08-04 02:18:20 责任编辑: 天之骄子           
网窝网版权所有webwoo.net!这里可以修改成你网站的信息
  概述

  C语言中有一种长度不确定的参数,形如:"…",它主要用在参数个数不确定的函数中,我们最容易想到的例子是printf函数。

  原型:

int printf( const char *format [, argument]... );

  使用例:

printf("Enjoy yourself everyday!/n");
printf("The value is %d!/n", value);

  这种可变参数可以说是C语言一个比较难理解的部分,这里会由几个问题引发一些对它的分析。

  注意:在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任意数量的函数参数。

  问题:printf的实现

  请问,如何自己实现printf函数,如何处理其中的可变参数问题? 答案与分析:

  在标准C语言中定义了一个头文件<stdarg.h>专门用来对付可变参数列表,它包含了一组宏,和一个va_list的typedef声明。一个典型实现如下:

typedef char* va_list;
#define va_start(list) list = (char*)&va_alist
#define va_end(list)
#define va_arg(list, mode)/
((mode*) (list += sizeof(mode)))[-1]
自己实现printf:
#include <stdarg.h>
int printf(char* format, …)
{
va_list ap;
va_start(ap, format);
int n = vprintf(format, ap);
va_end(ap);
return n;
}

  问题:运行时才确定的参数

  有没有办法写一个函数,这个函数参数的具体形式可以在运行时才确定?

  答案与分析:

  目前没有"正规"的解决办法,不过独门偏方倒是有一个,因为有一个函数已经给我们做出了这方面的榜样,那就是main(),它的原型是:

int main(int argc,char *argv[]);

  函数的参数是argc和argv。

  深入想一下,"只能在运行时确定参数形式",也就是说你没办法从声明中看到所接受的参数,也即是参数根本就没有固定的形式。常用的办法是你可以通过定义一个void *类型的参数,用它来指向实际的参数区,然后在函数中根据根据需要任意解释它们的含义。这就是main函数中argv的含义,而argc,则用来表明实际的参数个数,这为我们使用提供了进一步的方便,当然,这个参数不是必需的。

  虽然参数没有固定形式,但我们必然要在函数中解析参数的意义,因此,理所当然会有一个要求,就是调用者和被调者之间要对参数区内容的格式,大小,有效性等所有方面达成一致,否则南辕北辙各说各话就惨了。

  问题:可变长参数的传递

  有时候,需要编写一个函数,将它的可变长参数直接传递给另外的函数,请问,这个要求能否实现?

  答案与分析:

  目前,你尚无办法直接做到这一点,但是我们可以迂回前进,首先,我们定义被调用函数的参数为va_list类型,同时在调用函数中将可变长参数列表转换为va_list,这样就可以进行变长参数的传递了。看如下所示:

void subfunc (char *fmt, va_list argp)
{
...
arg = va_arg (fmt, argp); /* 从argp中逐一取出所要的参数 */
...
}

void mainfunc (char *fmt, ...)
{
va_list argp;
va_start (argp, fmt); /* 将可变长参数转换为va_list */
subfunc (fmt, argp); /* 将va_list传递给子函数 */
va_end (argp);
...
}

  问题:可变长参数中类型为函数指针

  我想使用va_arg来提取出可变长参数中类型为函数指针的参数,结果却总是不正确,为什么?

  答案与分析:

  这个与va_arg的实现有关。一个简单的、演示版的va_arg实现如下:

#define va_arg(argp, type) /
(*(type *)(((argp) += sizeof(type)) - sizeof(type)))

  其中,argp的类型是char *。

  如果你想用va_arg从可变参数列表中提取出函数指针类型的参数,例如

int (*)(),则va_arg(argp, int (*)())被扩展为:
(*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))

  显然,(int (*)() *)是无意义的。

  解决这个问题的办法是将函数指针用typedef定义成一个独立的数据类型,例如:

typedef int (*funcptr)();

  这时候再调用va_arg(argp, funcptr)将被扩展为:

(* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))

  这样就可以通过编译检查了。

  问题:可变长参数的获取

  有这样一个具有可变长参数的函数,其中有下列代码用来获取类型为float的实参:

va_arg (argp, float);

  这样做可以吗?

  答案与分析:

  不可以。在可变长参数中,应用的是"加宽"原则。也就是float类型被扩展成double;char, short被扩展成int。因此,如果你要去可变长参数列表中原来为float类型的参数,需要用va_arg(argp, double)。对char和short类型的则用va_arg(argp, int)。

  问题:定义可变长参数的一个限制

  为什么我的编译器不允许我定义如下的函数,也就是可变长参数,但是没有任何的固定参数?

int f (...)
{
...
}

  答案与分析:

  不可以。这是ANSI C 所要求的,你至少得定义一个固定参数。

  这个参数将被传递给va_start(),然后用va_arg()和va_end()来确定所有实际调用时可变长参数的类型和值。

---------------------------------------------------------------------------------------------------------------------
创建可变参数的函数

2006-10-26 22:54:33 / 天气: 晴朗 / 心情: 高兴 / 个人分类:vim专栏

我们平常定义的函数中,用的参数接口大多数都是固定的。也就是说,传进这个函数的参数个数是固定的,这样对于要实现某些功能时,函数的灵活性就显得不高了。如果是能定义一个可变参数的函数,那么灵活性就会高很多了。就像我们经常在编写C程序时用的printf()函数一样,可以改变参数的个数。现在让我们来做一个可变参数的函数,用这个函数来实现查找出参数中最大的一个参数并返回给主程序。我们来看一下源代码:

#include <stdio.h>
#include <stdarg.h>
int IntMax(int first, ...)
{
 va_list vl;
 int tmp1,max;
 tmp1=first;
 max=tmp1;
 va_start(vl,first);
 while(tmp1!=-1)
 {
  tmp1=va_arg(vl,int);
  if(max<tmp1)
   max=tmp1;
 }
 va_end(vl);
 return max;
}
void main()
{
 printf("最大为%d/n",IntMax(10,20,4,6,-1));
 printf("最大为%d/n",IntMax(5,2,1,-1));
}
执行一下这段程序,我们可以得出下面的结果:

最大为20

最大为5

 

从主函数中的两条printf函数中调用的IntMax函数里面的参数是不同的。那么我们是怎样实现的呢?我们来看一下IntMax函数。

int IntMax(int first, ...)

可以看得到在int first的后面有"...",这是声明可变参数函数必要的,如果不写就会导致编译错误。

然后我们在IntMax的函数体中又看到了va_list vl,这是用来访问可变参数用的。接着下面的va_start、va_arg以及va_end是宏,它们包含在stdarg.h头文件中。其中 va_start使vl指向第一参数,va_arg用来遍历每一个参数,va_end用来清空vl指针。看看函数调用时实际发生的情况,在函数调用的时候,使用栈传递参数,也就是所函数将每一个参数都压进栈中了,而且是按顺序压栈的(假如它是由右至左将参数压栈),那么上面的主程序中调用的IntMax (10,20,4,6,-1)进栈情况如下:


可以看出来,传递给函数的参数是存放在一段有顺序的内存中的。而且我们只要将指针指向第一参数,然后按顺序逐个取出来就可以了。

就这么容易我们就可以定义一个函数了。

---------------------------------------------------------------------------------------------------------------------
C语言函数中利用指针引用可变参数的方法
2006-9-22 网友评论 0 条 点击进入论坛

在C语言的程序设计中,用户程序的功能快都是一些函数,而函数在定义时,可选用省略号来表示参数类型和个数的不确定性。如function(F1,…)的函数的第一个参数F1表示为某种类型的变量,而后的其它参数无论是类型还是参数个数都不确定。在c函数体内,对用省略号说明的参数不能直接用参数名来引用,但可用参数的地址引用,如何取得省略参数的地址是引用省略号参数的关键。

在c函数调用时,参数或参数的指针都被压入堆栈,并且最后一个参数最先进入堆栈,第一个参数最后进入堆栈。如果小系统模式编译,变量的指针为2字节,如果用大系统模式编译,变量的指针为4字节,如果我们求得第一个参数指针在堆栈内的地址,加上变量指针的字节数,再取相应内存的内容,即求出其它各参数指针在堆栈内的地址,从而可引用用省略号说明的参数。

以下用小型模式举例引用可变参数的格式输入函数:

inputpict(char *format,…)
{
   char ff,str[256];
   void *p; /*此无类型指针可指向任意类型的变量p */
   p=*(&format+1);
   getspict(*format); /*按各式输入字符串*/
   ff-toupper(*format); /*取须返回变量类型*/
   switch(ff)
   {
      case ''I'':{
         int *a;
         a=p;
         *a=atoi(str);
         break; /*返回整型变量处理*/
      }
      case ''L'':{
         long *a;
         a=p;
         *a=atol(str);
         break; /*返回长整型变量处理*/
      }
     case ''F'':{
         float *a;
         a=p;
         *a=(float)atof(str);
         break; /*返回浮点数处理*/
      }
      case ''D'':{
         double *a;
         a=p;
         *a=atof(str);
         break; /*返回双精度浮点数处理*/
      }
      case ''C'':{
         char *a;
         a=p;
         strcpy(a,str);
         break; /*返回字符串处理*/
      }
      default:
         error("Error!"); /*用户自定义出错时的信息*/
      }
   return;
}

对函数的几点说明:

该函数是一个格式输入函数,format为格式串"Fn.n",F为:''I''整数;''L''长整数…两个n分别表示小数点前和后的位数。二省略号说明部分是一个变量的地址,即指针类型变量,其中getcspict()函数位按格式输入串。

注意:p=*(format+1);这一语句的无类型指针p取的是format的地址加1的内容,这与前面的说明堆栈内指针地址应加2不一致,原因是该指针在编译是乘上了指针放大因子2。经多个版本的c编译程序编译都证明在此处加1的结果才是正确的。

================================================================================
================================================================================
================================================================================