说实话，第一次接触这三个新的函数确实有点蒙，也是折腾了好长时间才明白到底是做什么用的，前面转载的那篇论文写的不错，可惜本人的文科太差，读起来有些费力，现在了解了，我就说一下它主要用途吧.

       相信大多数人接触这3个函数应该是在数据结构的数组和广义表这一章节中，大家发现了没有在对数组基本操作函数原型说明中很多的变量都用"..."给省略了如下

       status Initarray(array &a,int din,...);//若维数din和随后的长度合法,则构造相应的数组A,并返回OK。

       status value(array a,ElemType &e,...);//若各下标(这里的下标在函数中是"...")不超界则e赋值为所指定的A的元素之，并返回OK

       那这个省略号所代表的数值如何提取呢？请看如下的一个简单的程序

#include<stdio.h>

#include<stdarg.h>

int N=5;

void Stdarg(int a1,...)//这里一定要用3个'.'表示省略，多一个少一个都会犯错，我试过了

{

    va_list argp;//这里定义argp是可变参数的类型，

    int i;

    int ary[5];

    va_start(argp,a1);//这里的a1就是5,这句话的作用好比指针，让argp指向a1

    ary[0]=a1;

    for(i=1;i<N;i++)

       ary[i]=va_arg(argp,int);//每运行一次va_arg则argp自动指向下一个变量比如第一次运行是5第二次所得到的值就是12了

    va_end(argp);//有点像文件章节的脱钩fclose的性质让argp脱钩

    for(i=0;i<N;i++)

    printf("%d ",ary[i]);

}

void main()

{

    Stdarg(5,12,64,34,23);

}

这样一解释大家应该明白这4个函数到底是做什么用了吧,再一些细节，我就讲不出了由于水平有限只能解释道这里了如果还有什么不明白的就看我那个转载的，那个写得太详细里。

       有一个地方不得不说一下va_arg(argp,int);这个函数每运行一次argp的指针指向下一个地址但是这个下一个地址是下一个数值的地址而并不是内存中的地址如表

 

argp第一次指向的是5也就是指向1000这个地址再一次运行va_arg(argp,int);的时候argp指针改变指向的是12的地址8000也可能是1002(这个地址完全是系统自动分配的，并不是以线形方式进行分配)以此类推

还有一点要说明一下

va_start(argp,a1);

    ary[0]=a1;

    for(i=1;i<N;i++)/**********************/

       ary[i]=va_arg(argp,int);

大家发现没有i从1开始

因为va_start(argp,a1);这个函数让argp指向a1的时候的同时argp也像下移动到下一个变量的位置了希望大家能够明白。

 

 

1:当无法列出传递函数的所有实参的类型和数目时,可用省略号指定参数表

void foo(...);

void 

foo(parm_list,...);

 

2:函数参数的传递原理

函数参数是以数据结构:栈的形式存取,从右至左入栈.eg:

#include 

<iostream>

void fun(int a, ...)

{

int *temp = 

&a;

temp++;

for (int i = 0; i < a; ++i)

{

cout << *temp 

<< endl;

temp++;

}

}

 

int main()

{

int a = 1;

int b = 2;

int c = 3;

int d = 

4;

fun(4, a, b, c, d);

system("pause");

return 

0;

}

Output::

1

2

3

4

 

3:获取省略号指定的参数

在函数体中声明一个va_list，然后用va_start函数来获取参数列表中的参数，使用完毕后调用va_end()结束。像这段代码：

void 

TestFun(char* pszDest, int DestLen, const char* pszFormat, ...)

{

va_list 

args;

va_start(args, 

pszFormat);

_vsnprintf(pszDest, DestLen, pszFormat, 

args);

va_end(args);

}

 

4.va_start使argp指向第一个可选参数。va_arg返回参数列表中的当前参数并使argp指向参数列表中的下一个参数。va_end把argp指针清为NULL。函数体内可以多次遍历这些参数，但是都必须以va_start开始，并以va_end结尾。

 

　　1).演示如何使用参数个数可变的函数，采用ANSI标准形式

　　#include 〈stdio.h〉

　　#include 

〈string.h〉

　　#include 〈stdarg.h〉

　　

　　int demo( char, ... );

　　void 

main( void )

　　{

　　   demo("DEMO", "This", "is", "a", "demo!", 

"");

　　}

　　

　　int demo( char msg, ... 

)

　　{

      

　　   va_list 

argp;

　　   int argno = 0;

　　   char para;

 

　　  

　　   va_start( argp, msg 

);

　　   while (1)

       

{

　　    para = va_arg( argp, 

char);

　　       if ( strcmp( para, "") == 0 

)

       

break;

　　       printf("Parameter #%d is: 

%s\n", argno, para);

　　       argno++;

　　 

}

　　 va_end( argp );

　　

　　　return 0;

　　}

 

2)//示例代码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;

}

 

3)//示例代码2:扩展——自己实现简单的可变参数的函数。

下面是一个简单的printf函数的实现，参考了<The C Programming 

Language>中的例子

#include "stdio.h"

#include "stdlib.h"

void 

myprintf(char* fmt, ...)        

//一个简单的类似于printf的实现，//参数必须都是int 类型

{

    char* 

pArg=NULL;               

//等价于原来的va_list

    char 

c;

   

    pArg = (char*) 

&fmt;          //注意不要写成p = fmt 

!!因为这里要对//参数取址，而不是取值

    pArg += 

sizeof(fmt);         //等价于原来的va_start         

    

do

    {

        c 

=*fmt;

        if (c != 

'%')

        

{

            

putchar(c);            

//照原样输出字符

        

}

        

else

        

{

           

//按格式字符输出数据

           

switch(*++fmt)

           

{

            

case'd':

                

printf("%d",*((int*)pArg));          

                

break;

            

case'x':

                

printf("%#x",*((int*)pArg));

                

break;

            

default:

                

break;

            

}

            pArg += 

sizeof(int);               

//等价于原来的va_arg

        

}

        ++fmt;

    

}while (*fmt != '\0');

    pArg = 

NULL;                               

//等价于va_end

    return;

}

int main(int argc, char* 

argv[])

{

    int i = 1234;

    int j = 

5678;

   

    myprintf("the first 

test:i=%d\n",i,j);

    myprintf("the secend test:i=%d; 

%x;j=%d;\n",i,0xabcd,j);

    

system("pause");

    return 0;

}

 

 

1. 概述
   由于在C语言中没有函数重载,解决不定数目函数参数问题变得比较麻烦;即使采用C++,如果参数个数不能确定,也很难采用函数重载.对这种情况,有些人采用指针参数来解决问题.下面就c语言中处理不定参数数目的问题进行讨论.
2. 定义
   大家先看几宏.
   在VC++6.0的include有一个stdarg.h头文件,有如下几个宏定义:
   #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 )                            // 将指针置为无效
   如果对以上几个宏定义不理解,可以略过,接这看后面的内容.
3. 参数在堆栈中分布,位置
   在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地 址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,执行自己的代码来达 到执行自己插入的代码段的目的.
   总之,函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.
   堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
   最后一个参数
   倒数第二个参数
   ...
   第一个参数
   函数返回地址
   函数代码段
4. 示例代码
   void arg_test(int i, ...);
   int main(int argc,char *argv[]) 
   {
    int int_size = _INTSIZEOF(int);
    printf("int_size=%d\n", int_size);
    arg_test(0, 4);
    
    arg_cnt(4,1,2,3,4);
    return 0;
   }
   void arg_test(int i, ...)
   {
    int j=0; 
    va_list arg_ptr; 
    
    va_start(arg_ptr, i); 
    printf("&i = %p\n", &i);//打印参数i在堆栈中的地址
    printf("arg_ptr = %p\n", arg_ptr);
    //打印va_start之后arg_ptr地址,
    //应该比参数i的地址高sizeof(int)个字节
    //这时arg_ptr指向下一个参数的地址
    
    j=*((int *)arg_ptr);
    printf("%d %d\n", i, j); 
    j=va_arg(arg_ptr, int); 
    printf("arg_ptr = %p\n", arg_ptr);
    //打印va_arg后arg_ptr的地址
    //应该比调用va_arg前高sizeof(int)个字节
    //这时arg_ptr指向下一个参数的地址
    va_end(arg_ptr); 
    printf("%d %d\n", i, j); 
   }
5. 代码说明:
   int int_size = _INTSIZEOF(int);得到int类型所占字节数
    va_start(arg_ptr, i); 得到第一个可变参数地址,

   根据定义(va_list)&v得到起始参数的地址, 再加上_INTSIZEOF(v) ,就是其实参数下一个参数的地址,即第一个可变参数地址.

   j=va_arg(arg_ptr, int); 得到第一个参参数的值,并且arg_ptr指针上移一个_INTSIZEOF(int),即指向下一个可变参数的地址.
   va_end(arg_ptr);置空arg_ptr,即arg_ptr=0;
   总结:读取可变参数的过程其实就是堆栈中,使用指针,遍历堆栈段中的参数列表,从低地址到高地址一个一个地把参数内容读出来的过程.

6. 在编程中应该注意的问题和解决办法
   虽然可以通过在堆栈中遍历参数列表来读出所有的可变参数,但是由于不知道可变参数有多少个,什么时候应该结束遍历,如果在堆栈中遍历太多,那么很可能读取一些无效的数据.
   解决办法:a.可以在第一个起始参数中指定参数个数,那么就可以在循环还中读取所有的可变参数;b.定义一个结束标记,在调用函数的时候,在最后一个参数中传递这个标记,这样在遍历可变参数的时候,可以根据这个标记结束可变参数的遍历;
   下面是一段示例代码:
   //第一个参数定义可选参数个数,用于循环取初参数内容
   void arg_cnt(int cnt, ...);
   int main(int argc,char *argv[]) 
   {
    int int_size = _INTSIZEOF(int);
    printf("int_size=%d\n", int_size);
    arg_cnt(4,1,2,3,4);
    return 0;
   }
   void arg_cnt(int cnt, ...)
   {
    int value=0; 
    int i=0;
    int arg_cnt=cnt; 
    va_list arg_ptr; 
    va_start(arg_ptr, cnt); 
    for(i = 0; i < cnt; i++)
    {
     value = va_arg(arg_ptr,int);
     printf("value%d=%d\n", i+1, value);
    }
   }
   虽 然可以根据上面两个办法解决读取参数个数的问题,但是如果参数类型都是不定的,该怎么办,如果不知道参数的类型,即使读到了参数也没有办法进行处理.解决 办法:可以自定义一些可能出现的参数类型,这样在可变参数列表中,可以可变参数列表中的那类型,然后根据类型,读取可变参数值,并进行准确地转换.传递参 数的时候可以这样传递:参数数目,可变参数类型1,可变参数值1,可变参数类型2,可变参数值2,....
   这里给出一个完整的例子:
   #include <stdio.h>
   #include <stdarg.h>
   const int INT_TYPE  = 100000;
   const int STR_TYPE  = 100001;
   const int CHAR_TYPE  = 100002;
   const int LONG_TYPE  = 100003;
   const int FLOAT_TYPE = 100004;
   const int DOUBLE_TYPE = 100005;
   //第一个参数定义可选参数个数,用于循环取初参数内容
   //可变参数采用arg_type,arg_value...的形式传递,以处理不同的可变参数类型
   void arg_type(int cnt, ...);
   //第一个参数定义可选参数个数,用于循环取初参数内容
   void arg_cnt(int cnt, ...);
   //测试va_start,va_arg的使用方法,函数参数在堆栈中的地址分布情况
   void arg_test(int i, ...);
   int main(int argc,char *argv[]) 
   {
    int int_size = _INTSIZEOF(int);
    printf("int_size=%d\n", int_size);
    arg_test(0, 4);
    
    arg_cnt(4,1,2,3,4);
    arg_type(2, INT_TYPE, 222, STR_TYPE, "ok,hello world!");
    return 0;
   }

void arg_test(int i, ...)

{

 int j=0; 

 va_list arg_ptr; 

 

 va_start(arg_ptr, i); 

 printf("&i = %p\n", &i);//打印参数i在堆栈中的地址

 printf("arg_ptr = %p\n", arg_ptr);

 //打印va_start之后arg_ptr地址,

 //应该比参数i的地址高sizeof(int)个字节

 //这时arg_ptr指向下一个参数的地址

 

 j=*((int *)arg_ptr);

 printf("%d %d\n", i, j); 

 j=va_arg(arg_ptr, int); 

 printf("arg_ptr = %p\n", arg_ptr);

 //打印va_arg后arg_ptr的地址

 //应该比调用va_arg前高sizeof(int)个字节

 //这时arg_ptr指向下一个参数的地址

 va_end(arg_ptr); 

 printf("%d %d\n", i, j); 

}

void arg_cnt(int cnt, ...)

{

 int value=0; 

 int i=0;

 int arg_cnt=cnt; 

 va_list arg_ptr; 

 va_start(arg_ptr, cnt); 

 for(i = 0; i < cnt; i++)

 {

  value = va_arg(arg_ptr,int);

  printf("value%d=%d\n", i+1, value);

 }

}

void arg_type(int cnt, ...)

{

 int arg_type = 0;

 int int_value=0; 

 int i=0;

 int arg_cnt=cnt; 

 char *str_value = NULL;

 va_list arg_ptr; 

 va_start(arg_ptr, cnt); 

 for(i = 0; i < cnt; i++)

 {

  arg_type = va_arg(arg_ptr,int);

  switch(arg_type)

  {

  case INT_TYPE:

   int_value = va_arg(arg_ptr,int);

   printf("value%d=%d\n", i+1, int_value);

   break;

  case STR_TYPE:

   str_value = va_arg(arg_ptr,char*);

   printf("value%d=%d\n", i+1, str_value);

   break;

  default:

   break;

  }

 }

}