最近在学习linux内核的时候用到了自定义实现的printf，学习了一下，在此记录，希望有助于大家。
在C语言中，我们用到的最多的输出功能函数大概就是printf了。但以前只是调用C语言的库函数，具体printf是如何实现的呢？
说到底两件事：
（1）、函数变参
（2）、格式解析
下面将简要介绍以上两点内容，最后附一个简单的printf例子。
何为函数变参？简要来说就是参数个数不固定的函数。大部分时间，我们用的、写的都是参数固定的函数。但是为了应对想printf这种参数不固定的函数（），C语言提供了一种变参函数的机制。
int printf (const char *__format, ...);
如上所示为pritnf的声明。其中format就是我们以前写的格式化字符串，其中包括我们想输出的内容和参数占位符（用%+格式化字符来占位）。后面的 ‘…’，就是代表不固定的参数。
我们调用的使用像下面这样进行调用：
printf（“This is a test: %d,%c,%s”,a,b,c）;
这里的…，就代表了a,b,c三个参数。
说完了变参函数的概念，下面说说变参函数的实现原理。
我们知道，在调用函数的时候，函数的参数是在栈中分配的。 比如说调用下面这个普通函数。
//函数声明
int Add(int a,int b);
//函数调用
Add(3,5);
其栈大概是向下面这样分配的。
如下图所示。
即，一般来说，栈空间是从搞地址向低地址分配，函数参数从右依次向左分配。分配完成之后，在函数内部的操作就是对这栈空间的变量进行的操作，这也是为什么我们在函数内部改变传入参数的值，却不能够传到函数外部的原因（如果不使用指针或者地址的话）。
而对于变参函数来说，其基本的传参原则是和上面说的一致。但是 由于其函数声明参数并不固定，所以有些栈中的变量是没有名字的，我们如果想使用这段空间，必须由我们自己通过指针来实现。
是不是有点蒙圈，有点绕？
小二，来点栗子。
如果我这样调用printf函数
printf（“This is a test: %d,%c,%s”,10,'A',"helloworld"）;
看下面栈的内存分配图。
如上图所示，在栈中只有format变量（字符指针类型，在printf的声明函数中定义了此参数），是有名字的，其他的三个内存空间里面只有值，但是没有名字来指明它们。所以，我们只能通过地址变量来找到（访问）它们。
这里要稍微补充一点，一般来说，对于变参函数来说，虽然其参数的个数是不固定的，但是其最少要有一个参数，就像printf函数中至少要有一个format参数一样（好像在宏定义变参函数中，可以由0个参数，这里不讨论）。
为什么呢？
答：这个最少要有的一个参数一般就是用来定位栈顶空间的。就像我们在上面描述的那样，栈内存的分配是从右向左的，最左边的参数就是栈顶元素。相当于，我们知道了栈顶的地址，只要再根据变参中每个参数的类型（int、char型等），相应的进行地址偏移，就可以访问变参的内容。
哎呀，又有一个问题了，在被调用的函数内部我怎么知道变参的类型是什么呢？
嘿嘿，还真是，一般你还真是不知道。这种情况下就需要调用者和被调用者商量好了。对于printf函数来说，调用者通过%+格式字符的方式通知了被调用者（printf的实现者）。
怎么通知的呢？
答：就是通过第一个format参数了。因为%+格式字符都是在format参数里的啊。
弄懂了上面所说的，剩下的就没什么好说的了。 简单提一下。
简单来说就是扫描format参数里的字符，如果是普通字符就打印输出，如果是%，就说明后面有可能是格式字符，需要进行检测，然后从栈顶（其实是第一个参数的位置）弹出指定类型的数据，按照指定格式（十进制、十六进制、指定宽度、指定精度等等）进行输出。
基本上是一个字符串解析的过程。后面代码有解析，在此就不详述了。
//从传递的栈中获取参数的一些设置
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 )
#define BUFFER_SIZE 4096
static char print_buf[BUFFER_SIZE];
static char num_to_char[] = "0123456789ABCDEF";
//将十进制数据转化为字符型数据
int fillD(char print_buf[],int k,int num,int base)
{
int i;
int tmp;
char tmp_str[BUFFER_SIZE] = {0};
int tmp_index = 0;
if(num == 0)
tmp_str[tmp_index++] = '0';
else if(num < 0) //如果是负数的话，记录下符号后转为相反的数
{
print_buf[k++] = '-';
num = -num;
}
//将num转化为base进制的数据
while(num > 0)
{
tmp = num % base; //取最低位元素
tmp_str[tmp_index++] = num_to_char[tmp]; //入栈，填入字符型数字
num = num/ base;
}
//将字符型数字出栈倒入buf中
for(i = tmp_index-1;i>=0;--i)
{
print_buf[k++] = tmp_str[i];
}
return k;
}
//填充字符串
int fillStr(char print_buf[],int k,char * src)
{
int i = 0;
for(;src[i] != '\0';++i)
{
print_buf[k++] = src[i];
}
return k;
}
//处理具体的解析，并输出到printf_buf中 //I , %c take %d years to %x fin %s ished it\n ;
int my_vsnprintf(char print_buf[],int size,const char *fmt,va_list arg_list)
{
int i = 0,k = 0;
char tmp_c = 0;
int tmp_int = 0;
char *tmp_cp = NULL;
for(i = 0;i<size && fmt[i] != '\0';++i)
{
if('%' != fmt[i] ) //直接输出的普通格式字符
{
print_buf[k++] = fmt[i];
}
else //需要特殊处理的字符
{
if(i+1 < size)
{
switch(fmt[i+1])
{
case 'c': //处理字符型数据
tmp_c = va_arg(arg_list,char); //获得字符型参数
print_buf[k++] = tmp_c;
break;
case 'd': //处理十进制数据
tmp_int = va_arg(arg_list,int);
k = fillD(print_buf,k,tmp_int,10); //填充十进制数据
break;
case 'x': //处理十六进制数据
//填充16进制标志符号
print_buf[k++] = '0';
print_buf[k++] = 'x';
tmp_int= va_arg(arg_list,int); //获取int型数据
k = fillD(print_buf,k,tmp_int,16); //填充十六进制数据
break;
case 's': //处理字符串
tmp_cp = va_arg(arg_list,char*); //获得字符串型数据
k = fillStr(print_buf,k,tmp_cp); //填充字符串
break;
}
}
else
print_buf[k++] = fmt[i]; //最后一个字符是%，直接读取即可
}
}
return k; //返回当前位置
}
//输出缓冲区里的字符
void __put_str(char print_buf[],int len)
{
int i = 0;
for(;i<len;++i)
putchar(print_buf[i]);
}
void printk( char const *fmt,...)
{
int len = 0;
va_list arg_list;
va_start(arg_list,fmt); //arg_list指向第一个参数的位置(不是fmt)
len = my_vsnprintf(print_buf,sizeof(print_buf),fmt,arg_list); //解析参数，并打印到输出中
va_end(arg_list); //变参结束
__put_str(print_buf,len); //转换成字符输出
}
是不是懂了？做个作业呗。
1、以下代码段是C语言提供的变参函数的主要代码部分，你看看，能看的懂吗？
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 )
2、一般情况下，在传递字符串参数的时候，为何在栈中保存的都是字符串的首地址，而不是整个字符串内容呢？
这么简单的问题，一定难不倒你了。
按理说，函数形参的传递在栈内存中的分布应该是和我上面说的差不多，但是最近在做实验的时候，发现了不一样的结果。形式上是函数调用栈空间是从下往上的。具体原因，也不是很了解，如果有懂的大佬，希望帮我指点下迷津。
以下是我的测试代码：
#include<stdio.h>
void func(char a, short int b,int c,int d)
{
printf("a = %c,&a = %0x\n",a,&a);
printf("b = %d,&b = %0x\n",b,&b);
printf("c = %d,&c = %0x\n",c,&c);
printf("d = %d,&d = %0x\n",d,&d);
}
int main()
{
func('a',10,20,30);
return 0;
}
在window上结果是
这个结果是符合预期的。
但是,在linux上测试出现了下面的现象，
完全和上面的地址顺序相反。
了解吗？给我解释一下呗。