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++的程序中。

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

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

• 首先在函数里定义一个va_list型的变量，这里是arg_ptr，这个变量是指向参数的指针。 
• 然后用va_start宏初始化变量arg_ptr，这个宏的第二个参数是第一个可变参数的前一个参数，是一个固定的参数. 
• 然后用va_arg返回可变的参数，并赋值给整数j；va_arg的第二个参数是你要返回的参数的类型，这里是int型。
• 最后用va_end宏结束可变参数的获取。然后你就可以在函数里使用第二个参数了。如果函数有多个可变参数的。依次调用va_arg获取各个参数。

如果我们用下面三种方法调用的话,都是合法的,但结果却不一样: 

我们看到第一种调用有错误，第二种调用正确，第三种调用尽管结果正确，但和我们函数最初的设计有冲突。

下面一节我们探讨出现这些结果的原因和可变参数在编译器中是如何处理的。

下面以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指向第一个可变参数在堆栈的地址。如图:

图( 1 )

然后，我们用va_arg()取得类型t的可变参数值，以上例为int型为例，我们看一下va_arg取int型的返回值:

　　j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) ); 

首先ap += sizeof(int)，已经指向下一个参数的地址了。然后返回 ap-sizeof(int) 的 int* 指针，这正是第一个可变参数在堆栈里的地址(图2)。然后用*取得这个地址的内容(参数值)赋给j。如图：

图( 2 )

最后要说的是va_end宏的意思。X86平台定义为ap=(char*)0；使ap不再指向堆栈，而是跟NULL一样。有些直接定义为((void*)0)，这样编译器不会为va_end产生代码，例如gcc在linux的x86平台就是这样定义的。

在这里大家要注意一个问题：由于参数的地址用于va_start宏，所以参数不能声明为寄存器变量或作为函数或数组类型。

关于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的定义就够了，也便于程序的移植。

总结如下：

头文件stdarg.h中说明了一个类型(va_list)和三个宏(va_start, va_arg和 va_end)。它们是专门用于可变参数表的函数编程。 

• va_list：本数组用于存放va_arg和va_end所需要的信息。当一被调用函数使用一 个可变参数表时，它说明一个类型为va_list的变量param。 
• void va_start(va_list param, lastfix); 本子程序使param指向被传送给函数的可变参数表的第一个参数。在调用va_arg和 va_end之前，必须先调用va_start。参数param已在前段va_list中解释，lastfix为传 递给被调用函数的最后一个固定参数的名。 
• type va_arg(va_list param, type); 本子程序扩展表达式使其与下一个被传递参数具有相同的类型和值。变量param应 与va_start初始化时的param相同。在第一次使用va_arg时返回表中第一个参数，后续 每次调用都返回表中的下一个参数。 
• void va_end(va_list param); 本宏用于被调用函数完成一正常返回。它可修改param使其在重新调用va_start以 前不能被使用。va_end必须在va_arg读完所有参数后才被调用，否则会产生意想不到的情况。 

/**********************
  * tscanf & tprintf   *
  **********************/

void nstrcpy( int n, char *str1, char *str2)
{
    int i;

    for( i=0; i<n; i++ ) 
    {
        str2[i] = str1[i];
    }

    /*cut off spaces in tail*/
    for( i = n-1; i >= 0; i-- ) 
    {
        if( str2[i] != ' ' ) 
        {
            break;
        }
    }

    str2[i+1] = '';
}

void fullstrcpy(int n, char *str1, char *str2 )
{
    int i;

    for( i=0; i<n; i++ ) 
    {
        str2[i] = str1[i];
    }

    str2[i]='';
}

void mstrcpy( int n, char *str1, char *str2 )
{
    int i;

    for( i=0; i<n; i++ )
    {
        if (str1[i] != '') 
        {
            str2[i] = str1[i];
        }
        else 
            break;
    }

    for( ; i<n; i++ )
        str2[i] = ' ';
}

/**************************************************************
 ** str: input text string                                   **
 ** fmt: <fmt>::="%c<fmt>"||"%<num>d<fmt>"||"%<num>l<fmt>"|| **
 ** "%<num>f<fmt>"||"%<num>s<fmt>"||"%<num>.<num>f"          **
 **************************************************************/
short int tscanf( char *str, char *fmt, ... )
{
    va_list arglist;
    char    c, c1, fmt1[16];
    int     idx1,idx2,len=0;
    int     state;
    double  x;

    idx1=idx2=state=0; /* init */

    va_start(arglist,fmt);

    while(1)
    {
        c=fmt[idx1];
        if( !c ) break;

        switch (state)
        {
            case 0:
                if( c=='%' ) state=1;
                break;

            case 1: /* '%'^ */
                if(c=='c')
                {
                    *va_arg(arglist,char*)=str[idx2];
                    idx2+=1;
                    state=0;
                }
                else if('0'<=c && c<='9')
                {
                    state=2;
                    len=c-'0';
                }
                else return(-1);
                break;

            case 2: /* '%'<num>^ */
                if( '0'<=c && c<='9' ) len=10*len+c-'0';
                else if(c=='.') state=4;
                else if(c=='d' || c=='f' || c=='s' || c=='S')
                {
                    c1=str[idx2+len];
                    str[idx2+len]=0;
                    if( c=='d' )
                        *va_arg(arglist,short int*)=atoi(str+idx2);
                    else if( c=='f' )
                        *va_arg(arglist,float*)=atof(str+idx2);
                    else if( c=='s' )
                        nstrcpy(len,str+idx2,va_arg(arglist,char*));
                    else if( c=='S' )
                        fullstrcpy(len,str+idx2,va_arg(arglist,char*));

                    idx2+=len;
                    str[idx2]=c1;
                    state=0;
                }
                else if(c=='h') state=2;
                else if(c=='l') state=3;
                else return(-1);
                break;

            case 3: /* '%'<num>'l'^ */
                if( c=='d' || c=='f' )
                {
                    c1=str[idx2+len];
                    str[idx2+len]='';
                    if( c=='d' ) *va_arg(arglist,long*)=atol(str+idx2);
                    else if( c=='f' ) *va_arg(arglist,double*)=atof(str+idx2);
                    idx2+=len;
                    str[idx2]=c1;
                    state=0;
                }
                else return(-1);
                break;

            case 4: /* '%'<num>'.'^ */
                if( '0'<=c && c<='9' ) state=5;
                else return(-1);
                break;

            case 5: /* '%'<num>'.'<num>^ */
                if( '0'<=c && c<='9' ) state=5;
                else if( c=='f' )
                {
                    c1=str[idx2+len];
                    str[idx2+len]='';
                    *va_arg(arglist,float*)=(float)atof(str+idx2);
                    idx2+=len;
                    str[idx2]=c1;
                    state=0;
                }
                else if( c=='l' ) state=6;
                else return(-1);
                break;

            case 6: /* '%'<num>'.'<num>'l'^ */
                if( c=='f' )
                {
                    c1=str[idx2+len];
                    str[idx2+len]='';
                    *va_arg(arglist,double*)=atof(str+idx2);
                    idx2+=len;
                    str[idx2]=c1;
                    state=0;
                }
                else return(-1);
                break;
        }/*end switch*/
        idx1++;
    } /*end while*/
    va_end(arglist);
    return(0);
}

/*************************************************************
 ** str: result text string                                 **
 ** fmt: <fmt>::="%c<fmt>"||"%<num>d<fmt>"||"%<num>l<fmt>"||**
 ** "%<num>f<fmt>"||"%<num>s<fmt>"||"%<num>.<num>f"         **
 *************************************************************/
short int tprintf( char *str, char *fmt1, ... )
{
    va_list     arglist;
    char        c, c1, *pc;
    static char fmt[500], buf[4000];
    int         idx1, idx2, len, len1, state, p1;

    strcpy(fmt,fmt1);
    idx1=idx2=state=0; /* init */
    va_start(arglist,fmt1);

    while( 1 )
    {
        c=fmt[idx1];
        if( c==0 )break;

        switch (state)
        {
            case 0:
                if( c=='%' ) { p1=idx1;state=1; }
                break;
            case 1:
                if( c=='c' )
                {
                    buf[idx2]=va_arg(arglist, int);
                    if (buf[idx2] == '') buf[idx2] = ' ';
                    idx2++;
                    state=0;
                }
                else if('0'<=c && c<='9')
                {
                    len=c-'0';
                    state=2;
                }
                else return(-1);
                break;

            case 2:/* '%'<num>^ */
                if( '0'<=c && c<='9' ) len=10*len+c-'0';
                else if(c=='.') state=3;
                else if( c=='d' || c=='f' )
                {
                    c1=fmt[idx1+1];
                    fmt[idx1+1]=0; 
                    if( c=='d' ) sprintf(buf+idx2,fmt+p1,va_arg(arglist, int));
                    else
                    { /* c=='f' */
                        sprintf(buf+idx2,fmt+p1,va_arg(arglist,double));
                    }
                    fmt[idx1+1]=c1;
                    idx2+=len;
                    state=0;
                }
                else if( c=='l' ) state=5;
                else if( c=='s' || c=='S')
                {
                    /* c1=fmt[idx1+1];
                    fmt[idx1+1]=0;
                    sprintf(buf+idx2,fmt+p1,va_arg(arglist,char*));*/
                    pc=va_arg(arglist,char*);
                    mstrcpy(len,pc,buf+idx2);

                    /* fmt[idx1+1]=c1;*/
                    idx2+=len;
                    state=0;
                }
                else if(c=='h') state=2;
                else return(-1);
                break;

            case 3: /* '%'<num>'.'^ */
                if('0'<=c && c<='9') state=4;
                else return(-1);
                break;

            case 4: /* '%'<num>'.'<num>^ */
                if( '0'<=c && c<='9' ) state=4;
                else if( c=='f' )
                {
                    c1=fmt[idx1+1]; 
                    fmt[idx1+1]=0; 
                    sprintf(buf+idx2,fmt+p1,va_arg(arglist,double));
                    fmt[idx1+1]=c1;
                    idx2+=len;
                    state=0;
                }
                else if( c=='l' ) state=6;
                else return(-1);
                break;

            case 5: /* '%'<num>'l'^ */
                if( c=='f' || c=='d' )
                {
                    c1=fmt[idx1+1];
                    fmt[idx1+1]=0;
                    if( c=='f' ) sprintf(buf+idx2,fmt+p1,va_arg(arglist,double));
                    else /* c=='d' */ sprintf(buf+idx2,fmt+p1,va_arg(arglist,long));
                    fmt[idx1+1]=c1;
                    idx2+=len;
                    state=0;
                }
                else return(-1);
                break;

            case 6: /* '%'<num>'.'<num>'l'^ */
                if( c=='f' )
                {
                    c1=fmt[idx1+1];
                    fmt[idx1+1]='';
                    sprintf(buf+idx2,fmt+p1,va_arg(arglist,double));
                    fmt[idx1+1]=c1;
                    idx2+=len;
                    state=0;
                }
                else return(-1);
                break;
        }/*end switch*/

    idx1++;

    } /*end while*/

    buf[idx2]='';
    strcpy(str,buf);

    va_end(arglist);
    return(0);
}

作者：谭辅州 2005-01-20