• C语言中的可变参数-printf的实现原理


    C语言中的可变参数-printf的实现原理

    在C/C++中,对函数参数的扫描是从后向前的。C/C++的函数参数是通过压入堆栈的方式来给函数传参数的(堆栈是一种先进后出的数据结构),最先压入的参数最后出来,在计算机的内存中,数据有2块,一块是堆,一块是栈(函数参数及局部变量在这里),而栈是从内存的高地址向低地址生长的,控制生长的就是堆栈指针了,最先压入的参数是在最上面,就是说在所有参数的最后面,最后压入的参数在最下面,结构上看起来是第一个,所以最后压入的参数总是能够被函数找到,因为它就在堆栈指针的上方。printf的第一个被找到的参数就是那个字符指针,就是被双引号括起来的那一部分,函数通过判断字符串里控制参数的个数来判断参数个数及数据类型,通过这些就可算出数据需要的堆栈指针的偏移量了,下面给出printf("%d,%d",a,b);(其中a、b都是int型的)的汇编代码.

    .section
    .data
    string out = "%d,%d"
    push b  //最后的先压入栈中
    push a //最先的后压入栈中
    push $out//参数控制的那个字符串常量是最后被压入的
    call printf
     
    你会看到,参数是最后的先压入栈中,最先的后压入栈中,参数控制的那个字符串常量是最后被压入的,所以这个常量总是能被找到的。
     
    通常情况下函数可变参数表的长度是已知的,通过num参数传入,这种函数比较容易实现。
    而printf函数的实现非常复杂因为
    1)可变参数的个数不能轻易的得到
    2)而可变参数的类型也不是固定的,需由格式字符串进行识别(由%f、%d、%s等确定)
    在这个函数中,需通过对传入的格式字符串(首地址为lpStr)进行识别来获知可变参数个数及各个可变参数的类型,具体实现体现在for循环中。譬如,在识别为%d后,做的是va_arg ( vap, int ),而获知为%l和%lf后则进行的是va_arg ( vap, long )、va_arg ( vap, double )。格式字符串识别完成后,可变参数也就处理完了。
     
     
    printf的简单实现:
    #include
    #include
     
    void myitoa(int n, char str[], int radix)
    {
    int i , j , remain;
    char tmp;
    i = 0;
    do
    {
    remain = n % radix;
    if(remain > 9)
    str[i] = remain  - 10 + 'A';
    else
    str[i] = remain + '0';
    i++;
    }while(n /= radix);
    str[i] = '';
     
    for(i-- , j = 0 ; j <= i ; j++ , i--)
    {
    tmp = str[j];
    str[j] = str[i];
    str[i] = tmp;
    }
     
    }
     
    void myprintf(const char *format, ...)
    {
    char c, ch, str[30];
    va_list ap;
     
    va_start(ap, format);
    while((c = *format))
    {
    switch(c)
    {
      case '%':
      ch = *++format;
      switch(ch)
      {
        case 'd':
        {
        int n = va_arg(ap, int);
        myitoa(n, str, 10);
        fputs(str, stdout);
        break;
        }
        case 'x':
        {
          int n = va_arg(ap, int);
          myitoa(n, str, 16);
          fputs(str, stdout);
          break;
        }
        case 'f':
        {
          double f = va_arg(ap, double);
          int n;
          n = f;
          myitoa(n, str, 10);
          fputs(str, stdout);
          putchar('.');
          n = (f - n) * 1000000;
          myitoa(n, str, 10);
          fputs(str, stdout);
          break;
        }
        case 'c':
        {
          putchar(va_arg(ap, int));
          break;
        }
        case 's':
        {
          char *p = va_arg(ap, char *);
          fputs(p, stdout);
          break;
        }
        case '%':
        {
          putchar('%');
          break;
        }
        default:
        {
          fputs("format invalid!", stdout);
          break;
        }
      }
      break;
      default:
        putchar(c);
        break;
      }
      format++;
    }
    va_end(ap);
    }
     
    int main(void)
    {
    myprintf("%d, %x, %f, %c, %s, %%,%a
    ", 10, 15, 3.14, 'B', "hello");
    return 0;
    }
    from:http://blog.csdn.net/hackbuteer1/article/details/7558979
  • 相关阅读:
    Redis之分布式锁的使用
    Redis之lua脚本
    Redis 集群的水平扩缩容
    Redis集群搭建及原理
    Redis 的主从、哨兵架构
    CompletableFuture 使用介绍
    Spring Boot 2.x使用H2数据
    pom.xml
    nexus-staging-maven-plugin 踩坑
    安卓Hook折腾研究的笔记记录
  • 原文地址:https://www.cnblogs.com/DXGG-Bond/p/11821985.html
Copyright © 2020-2023  润新知