可变参数模拟printf()函数实现一个my_print()函数以及调用可变参数需注意的陷阱...

最新推荐文章于 2022-05-11 20:43:38 发布

weixin_30389003

最新推荐文章于 2022-05-11 20:43:38 发布

阅读量246

点赞数

文章标签： c/c++

原文链接：http://www.cnblogs.com/tp-16b/p/7868960.html

版权

入栈规则

可变参数函数的实现与函数调用的栈帧结构是密切相关的。所以在我们实现可变参数之前，先得搞清楚栈是怎样传参的。

正常情况下，C的函数参数入栈遵照__stdcall规则, 它是从右到左的，即函数中的参数入栈是从右到左的。

例如：

1 void test(char a, int b,double c,char * d){
2     printf("a:%#p\nb:%#p\nc:%#p\nd:%#p",&a,&b,&c,d);
3 }
4 int main(){
5     char ch;
6     test('a',12,23,&ch);
7     return 0;
8 }

从各个形参变量的地址可以看出它们地址大小确实是从右到左依次减小的，说明它们是从右到左压栈的，

实现原理

对于固定参数列表的函数，每个参数的名称、类型都是直接可见的，他们的地址也都是可以直接得到的，比如：通过&a就可以得到a的地址，并通过函数原型声明了解到a是char类型的。

　　对于变长参数的函数，怎么办呢？其实想想函数传参的过程，无论"..."中有多少个参数、每个参数是什么类型的，它们都和固定参数的传参过程是一样的，简单来讲都是栈操作，同时C标准的说明中，是支持变长参数的函数在原型声明中的，但须至少有一个最左固定参数，嘿嘿~ 这样，我们不就可以得到其中固定参数的地址了吗？

　　知道了某函数帧的栈上的一个固定参数的位置，所以我们完全可以自己通过栈操作，推导出其他变长参数的位置，进而实现可变参数函数。（这个“固定的参数”一般就是可变参数函数里在第一个位置的参数，通过它就可以开始找到后面各种类型、个数不定的参数了）

（上述说了一下实现原理，知道的大佬就请忽略咯~）

实现步骤

我们常用的可变参数列表有这几个：
1.va_list

1 源码：typedef char * va_list;

va_list为char*类型重定义，所以va_list为一个指向char类型的指针(va_list p就等同于 char *p)

2.va_start(ap,v)

源码：1.#define va_start _crt_va_start
     2.#define _crt_va_start(ap,v) (ap=(va_list)_ADDRESSOF(v)+ _INTSIZEOF(V))

把v的地址强转为va_list类型即char* ,把其移动_INTSIZEOF(V)个字节后的地址赋值给ap，其实就是让ap跳过第一个参数，指向"..."里的第一个可变参数。
(这里这个_ADDRESSOF(v)是一个宏，对变量v取地址的意思；这个INSIZEOF(v)也是宏，是对变量v向上取4的倍数，
也就是说如果v占字节大小在1~4个字节范围内，就取4，v所占字节大小在5~8字节之间就取8，以此类推...
至于这里，_ADDRESSOF(v)，_INTSIZEOF(V)这两个宏怎么实现，后面有小弟我一点浅浅的见解~ ）

3.va_arg(ap,t)

源码：1.#define va_arg _crt_va_arg
     2.#define _crt_va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

它的作用就是将ap移动_INTSIZEOF(t)个字节后，然后再取出ap未移动前所指向位置对应的数据。

下面假使t为一个int型变量，如下图分析

4.va_end(ap)

源码：1.#define va_end _crt_va_end
     2.#define _crt_va_end(ap) ( ap = (va_list)0 )

将0强转为va_list类型,并赋值给ap,使其置空

于是这样就可以开始实现my_print函数

#include<stdio.h>
#include<assert.h>  
#include<stdarg.h>
void putInt(int n){
    if(n>9){
        putInt(n/10);
    }
    putchar(n%10+ '0');
}  
int My_print(const char *formt, ...)  
{  
    assert(formt);
    va_list arg;//定义arg  
    va_start(arg, formt);//初始化arg 即跳过传进来的第一个参数 ,这里相当于跳过"output:>%s %c %c %d"这个字符串   
    const char *start=formt;
    while (*start!= '\0')  
    {  
        if(*start =='%'){
            start++;
           switch(*start)  
           {  
             case 'd':
                 putInt(va_arg(arg, int));  
                break; 
             case 'c': 
                 putchar(va_arg(arg, int)); //char类型提升,用int类型。 
                break;
             case 's':  
              { /*puts(va_arg(arg, char*));*/   //字符串可以直接用puts()函数输出  
                 char *ch = va_arg(arg, char*);//定义一个指针变量接收获取的字符，用putchar（）一个一个输出  
                 while (*ch)  
                 {  
                   putchar(*ch);  
                   ch++;  
                 }  
              }
              break;
              case 'f':{
                  float a=(float)va_arg(arg,double);  //float类型提升，所以用double （小陷阱）
                  printf("%f",a);  //BUG  要模拟浮点型比较复杂，这里耍个小聪明~ 
              }
              break;
              default :  
              break; 
           }   
        }
        else {
            putchar(*start) ;
        }
     start++;  
    }  
    va_end(arg);   //必须有这一步，结束栈操作
    return 0;
} 

int main()  
{  
    char str[]="Beat box!";
    My_print("Output:>%f  %c%c %d %s",3.14,'t','p',1234,str) ;
    return 0;  
}

结果：

注意陷阱

从上面的例子中，不难注意到了这样一个问题，这里借助查询的资料来说明：

我们用va_arg(ap,type)取出一个参数的时候，
type绝对不能为以下类型：
——char、signed char、unsigned char
——short、unsigned short
——signed short、short int、signed short int、unsigned short int
——float

在没有函数原型的情况下，char与short类型都将被默认转换为int类型，float类型将被转换为double类型。
——《C语言程序设计》第2版 2.7 类型转换 p36

va_arg宏的第2个参数不能被指定为char、short或者float类型。
因为char和short类型的参数会被转换为int类型，而float类型的参数会被转换为double类型 ……
例如，这样写肯定是不对的：
c = va_arg(ap,char);
因为我们无法传递一个char类型参数，如果传递了，它将会被自动转化为int类型。上面的式子应该写成：
c = va_arg(ap,int);
　　　　　　　　　　　——《c陷阱与缺陷》

这就是在实现可变参数时，常常需要注意的小问题

至于前面所说的那两个宏

_ADDRESSOF(V)

源码：#define _ADDRESSOF(v)   ( &(v) )
其实就是对变量v取地址的意思。

_INTSIZEOF(v)

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

按式子可以先把这个宏改写成：（sizeof(n) + 4 - 1）& （-3）  然后传入变量 n，
n如占2个字节,就成了 5&（111...100）=4;
 如占3个字节，就成了6&（111...100）=4;
 如占5个字节，就成了8&（111...100）=8;
    。。。                                                               
 结果始终是4的倍数，如此便不难发现上面所述的规律了。

如有错误，希望指出！

欢迎来扰~~

转载于:https://www.cnblogs.com/tp-16b/p/7868960.html