C语言中可变函数参数变量的实现

VA_LIST：

VA_LIST 是在C语言中解决变参问题的一组宏，所在头文件：#include <stdarg.h>

他有这么几个成员

1） va_list型变量：

#ifdef _M_ALPHA

typedef struct {

char *a0; /* pointer to first homed integer argument */

int offset; /* byte offset of next parameter */

} va_list;

#else

typedef char * va_list;

#endif

_M_ALPHA是指DEC ALPHA（Alpha AXP）架构。所以一般情况下va_list所定义变量为字符^[1]指针。

2）_INTSIZEOF 宏

获取类型占用的空间长度，最小占用长度为int的整数倍：

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

3）VA_START宏

获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，v是可变参数最左边的参数）：

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

4）VA_ARG宏

获取可变参数的当前参数，返回指定类型并将指针指向下一参数（t参数描述了当前参数的类型）：

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

5）VA_END宏

清空va_list可变参数列表：

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

 

VA_LIST的用法：

1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针；

（2）然后用VA_START宏初始化变量刚定义的VA_LIST变量；

（3）然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用VA_ARG获取各个参数）；

（4）最后用VA_END宏结束可变参数的获取。

应该注意的问题：

（1）可变参数的类型和个数完全由程序代码控制,它并不能智能地识别不同参数的个数和类型；

（2）如果我们不需要一一详解每个参数，只需要将可变列表拷贝至某个缓冲，可用vsprintf函数；

（3）因为编译器对可变参数的函数的原型检查不够严格,对编程查错不利.不利于我们写出高质量的代码；

 

一个简易的功能实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <stack>

int show( int value,...)
{
    int argCnt = 0;
    //-1作为输出的结束符，毕竟是简易的嘛！ 
    int ret;
    int buf[256];
    va_list ap;
    va_start(ap,value);
    
    printf("%d\n",value);
    ret = va_arg(ap,int);
    while( ret != -1 )
    {
        argCnt++;
        printf("%d\n",ret);
        ret = va_arg(ap,int);
    }
    
    return argCnt;
    
}

int main()
{
    show(21,31,55,32,-1);
    return 0;
}

一个很不错的printf的的功能实现如下：

#include <stdio.h>
#include <stdarg.h>
#include "print.h"

int main(void)
{
    print("print: %c\n", 'c');
    print("print %d\n", 1234567);
    print("print: %f\n", 1234567.1234567);
    print("print: %s\n", "string test");
    print("print: %b\n", 0x12345ff);
    print("print: %x\n", 0xabcdef);
    print("print: %%\n");
    return 0;
}

void    print(char* fmt, ...)
{
    double vargflt = 0;
    int  vargint = 0;
    char* vargpch = NULL;
    char vargch = 0;
    char* pfmt = NULL;
    va_list vp;

    va_start(vp, fmt);
    pfmt = fmt;

    while(*pfmt)
    {
        if(*pfmt == '%')
        {
            switch(*(++pfmt))
            {
                
                case 'c':
                    vargch = va_arg(vp, int); 
                    /*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSI
                        mode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */
                    printch(vargch);
                    break;
                case 'd':
                case 'i':
                    vargint = va_arg(vp, int);
                    printdec(vargint);
                    break;
                case 'f':
                    vargflt = va_arg(vp, double);
                    /*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSI
                        mode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */
                    printflt(vargflt);
                    break;
                case 's':
                    vargpch = va_arg(vp, char*);
                    printstr(vargpch);
                    break;
                case 'b':
                case 'B':
                    vargint = va_arg(vp, int);
                    printbin(vargint);
                    break;
                case 'x':
                case 'X':
                    vargint = va_arg(vp, int);
                    printhex(vargint);
                    break;
                case '%':
                    printch('%');
                    break;
                default:
                    break;
            }
            pfmt++;
        }
        else
        {
            printch(*pfmt++);
        }
    }
    va_end(vp);
}

void    printch(char ch)
{
    console_print(ch);
}

void    printdec(int dec)
{
    if(dec==0)
    {
        return;
    }
    printdec(dec/10);
    printch( (char)(dec%10 + '0'));
}

void    printflt(double flt)
{
    int icnt = 0;
    int tmpint = 0;
    
    tmpint = (int)flt;
    printdec(tmpint);
    printch('.');
    flt = flt - tmpint;
    tmpint = (int)(flt * 1000000);
    printdec(tmpint);
}

void    printstr(char* str)
{
    while(*str)
    {
        printch(*str++);
    }
}

void    printbin(int bin)
{
    if(bin == 0)
    {
        printstr("0b");
        return;
    }
    printbin(bin/2);
    printch( (char)(bin%2 + '0'));
}

void    printhex(int hex)
{
    if(hex==0)
    {
        printstr("0x");
        return;
    }
    printhex(hex/16);
    if(hex < 10)
    {
        printch((char)(hex%16 + '0'));
    }
    else
    {
        printch((char)(hex%16 - 10 + 'a' ));
    }
}

C函数库中的printf()的函数实现如下：

int printf(const char *fmt, ...)
　　{
　　 int i;
　　 char buf[256];
　　
　　 va_list arg = (va_list)((char*)(&fmt) + 4); 
　　 i = vsprintf(buf, fmt, arg);
　　 write(buf, i);
　　
　　 return i;
　　}

参考资料：

http://baike.baidu.com/view/1213054.htm

http://blog.csdn.net/xfeng88/article/details/6695848