C|从底层认识可变参数列表和自定义实现printf()

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 )

先看一个使用可变参数的简单实例：

#include<stdio.h>
#include<stdarg.h>
void Average(int amount, ...)
{
    int i;
    double val,total=0.0;
    va_list arg;
    
    va_start(arg,amount);      // 得到可变参数列表的起始地址赋值给arg
	int t=(int)arg;
	printf ("浮点数: ");
    for (i=0;i<amount;i++)
    {
        val=va_arg(arg,double); // arg地址递增并取值
        printf("%8.2f",val);
        total+=val;
    }
    va_end(arg);                 // arg赋0值
    printf ("\n平均值:%f\n",total/3);

	int x =  ( (sizeof(amount) + sizeof(int) - 1) & ~(sizeof(int) - 1) );
	printf("%d\n",x);
	double d;

	for (i=0;i<4;i++)
	{
		int  y= (t += _INTSIZEOF(d)) - _INTSIZEOF(d);
		printf("%x\n",y);
	}
}
void main ()
{
    Average(3,10.0,40.0,13.0);

    getchar();
}
/*
浮点数:    10.00   40.00   13.00
平均值:21.000000
4
12fee0
12fee8
12fef0
12fef8
*/

1 void va_start(va_list argptr, prev_param);

初始化可变参数列表对象arg，使arg指向可变参数列表中的第一个可选参数

argptr指向可变参数列表中的第一个可选参数

prev_param是位于第一个可变参数之前的固定参数

2 type va_arg(va_list argptr, type)

返回可变参数列表中的参数，va表示variable argument

返回argptr指向的可变参数列表中的参数，并使argptr指向可变参数列表中的下一个参数

va_list是控制可变参数信息的类型

type表示要提取的参数类型

3 void va_end(va_list argptr)

终止使用可变参数列表argptr

通过stdarg.h简单自定义实现printf()：

#include <stdio.h>
#include <stdlib.h> // itoa()
#include <stdarg.h>
void myprintf(const char* format,...)
{
	va_list arg;
	va_start(arg,format);
	for (const char* p=format; *p!='\0'; p++)
	{
		if(*p!='%')
		{
			putchar(*p);
			continue;
		}
		switch(*++p)
		{
		case 'd':
			{
				int i = va_arg(arg,int);
				char str[22];
				fputs(itoa(i,str,10),stdout);
				break;
			}
		case 'c':
			{
				char ch=va_arg(arg,int);
				putchar(ch);
				break;
			}
		case 's':
			{
				char* q=va_arg(arg,char*);
				fputs(q,stdout);
				break;
			}
		default:
			putchar(*p);
		}
	}
	va_end(arg);
}

int main()
{
    int a=3,b=5,sum;
	char str[]="beijing university";
	sum=a+b;
	myprintf("%d+%d=%d\n",a,b,sum);
	myprintf("%s\n",str);
	getchar();
}
/*
3+5=8
beijing university
*/

分析字符串format的每一个字符，区分字符%后的每一个字符，分情况处理不同的类型，并映射到后面的变量列表。

以下是自定义实现printf()，没有使用到stdarg.h，而是通过宏来自定义实现，可以看到其中的微妙之处：

//va及自定义printf函数

#include<stdio.h>  //put()
//#include<stdarg.h>

typedef int* va_list1;
#define va_start1(ap, A)   (ap = (int *)&(A) + 1)
#define va_arg1(ap, T)     (*(T *)ap++)
#define va_end1(ap)        ((void)0)

char myitoa(unsigned long a, char * buf)
{
    unsigned long num = a;
    int i = 0;
    int len = 0;
    
    do 
    {
        buf[i++] = num % 10 + '0';
        num /= 10;        
    } while (num);
    buf[i] = '\0';
    
    len = i;
    for (i = 0; i < len/2; i++) // 字符逆转
    {
        char tmp;
        tmp = buf[i];
        buf[i] = buf[len-i-1];
        buf[len-i-1] = tmp;
    }
    
    return len;    
}

char itoa16(unsigned long a, char * buf)
{
    char index[]="0123456789ABCDEF";
    unsigned long num = a;
    int i = 0;
    int len = 0;
    for(i = 0; i < 8; i++)
    {
        buf[7-i] = index[num % 16];
        
        num /= 16;
    }
    buf[8] = '\0';
    len = 8;
    return len;    
}

int mysprintf(char *str, const char * format, va_list1 ap) // 输出变量str
{
    int i;
    char c;    
    char *ptr = str;
    
    char ch;
    char * p;
    unsigned long a;
    char buf[20]={'\0'};
    while ((c = *format++) != '\0')
    {
        switch (c)
        {
            ch = 0;
            a  = 0;
        case '%':
            c = *format++;
            switch (c)
            {                 
            case 'c':
                ch = va_arg1(ap, int);
                *ptr++ = ch;
                break;
            case 's':
                p = va_arg1(ap, char *);
                for(; *p != '\0'; p++)
                    *ptr++ = *p;
                break;                    
            case 'x':
                a = va_arg1(ap, int);
                itoa16(a,buf);                        
                p = buf;
                for(; *p != '\0'; p++)
                    *ptr++ = *p;
                break;        
            case 'd':
                a = va_arg1(ap, int);
                i = myitoa(a,buf);
                p = buf;
                for(; *p != '\0'; p++)
                    *ptr++ = *p;
                break;    
                
            default:
                break;
            }                
        break;        
        
        default:
            *ptr++ = c;
            break;
        }
    }
    *ptr = '\0';
    return 0;    
}
void myprintf(const char *fmt,...)
{
    va_list1 ap;
    char string[100];
    va_start1(ap, fmt);
    mysprintf(string, fmt, ap);
    puts(string);
    va_end1(ap);
}
int main()
{
    char str[66];
    int arr[3] = {33,'b','c'};
    //mysprintf(str,"%d,%c2%c",arr); 
    //printf("%s\n",str);//可通过调试，watch查看str到33,b2c
    myprintf("%dyear,%c2%c %s",2020,'b','c',"b2b");
    getchar();
    return 0;
}
//2020year,b2c b2b

－End－