C语言如何实现可变参数详解

编辑: admin 分类: c#语言 发布时间: 2022-03-15 来源:互联网
目录
  • 可变参数
  • 实现
    • 代码
  • 分析
    • 关键语句
    • 为什么
    • 内存地址
    • 难点
    • 优化
  • 总结

    可变参数

    可变参数是指函数的参数的数据类型和数量都是不固定的。

    printf函数的参数就是可变的。这个函数的原型是：int printf(const char *format, ...)。

    用一段代码演示printf的用法。

    // code-A
#include <stdio.h>
int main(int argc, char **argv)
{
   printf("a is %d, str is %s, c is %c\n", 23, "Hello, World;", 'A');
   printf("T is %d\n", 78);
   return 0;
}

    在code-A中，第一条printf语句有4个参数，第二条printf语句有2个参数。显然，printf的参数是可变的。

    实现

    代码

    code-A

    先看两段代码，分别是code-A和code-B。

    // file stack-demo.c

#include <stdio.h>

// int f(char *fmt, int a, char *str);
int f(char *fmt, ...);
int f2(char *fmt, void *next_arg);
int main(int argc, char *argv)
{
        char fmt[20] = "hello, world!";
        int a = 10;
        char str[10] = "hi";
        f(fmt, a, str);
        return 0;
}

// int f(char *fmt, int a, char *str)
int f(char *fmt, ...)
{
        char c = *fmt;
        void *next_arg = (void *)((char *)&fmt + 4);
        f2(fmt, next_arg);
        return 0;
}


int f2(char *fmt, void *next_arg)
{
        printf(fmt);
        printf("a is %d\n", *((int *)next_arg));
        printf("str is %s\n", *((char **)(next_arg + 4)));

        return 0;
}

    编译执行，结果如下：

    # 编译
    [root@localhost c]# gcc -o stack-demo stack-demo.c -g -m32
    # 反汇编并把汇编代码写入dis-stack.asm中
    [root@localhost c]# objdump -d stack-demo>dis-stack.asm
    [root@localhost c]# ./stack-demo
    hello, world!a is 10
    str is hi

    code-B

    // file stack-demo.c

#include <stdio.h>

// int f(char *fmt, int a, char *str);
int f(char *fmt, ...);
int f2(char *fmt, void *next_arg);
int main(int argc, char *argv)
{
        char fmt[20] = "hello, world!";
        int a = 10;
        char str[10] = "hi";
     char str2[10] = "hello";
        f(fmt, a, str, str2);
        return 0;
}

// int f(char *fmt, int a, char *str)
int f(char *fmt, ...)
{
        char c = *fmt;
        void *next_arg = (void *)((char *)&fmt + 4);
        f2(fmt, next_arg);
        return 0;
}


int f2(char *fmt, void *next_arg)
{
        printf(fmt);
        printf("a is %d\n", *((int *)next_arg));
        printf("str is %s\n", *((char **)(next_arg + 4)));
     printf("str2 is %s\n", *((char **)(next_arg + 8)));

        return 0;
}

    编译执行，结果如下：

    # 编译
    [root@localhost c]# gcc -o stack-demo stack-demo.c -g -m32
    # 反汇编并把汇编代码写入dis-stack.asm中
    [root@localhost c]# objdump -d stack-demo>dis-stack.asm
    [root@localhost c]# ./stack-demo
    hello, world!a is 10
    str is hi
    str2 is hello

    分析

    在code-A中，调用f的语句是f(fmt, a, str);；在code-B中，调用f的语句是f(fmt, a, str, str2);。

    很容易看出，int f(char *fmt, ...);就是参数可变的函数。

    关键语句

    实现可变参数的关键语句是：

    char c = *fmt;
void *next_arg = (void *)((char *)&fmt + 4);
printf("a is %d\n", *((int *)next_arg));
printf("str is %s\n", *((char **)(next_arg + 4)));
printf("str2 is %s\n", *((char **)(next_arg + 8)));
    • &fmt是第一个参数的内存地址。
    • next_arg是第二个参数的内存地址。
    • next_arg+4、next_arg+8分别是第三个、第四个参数的内存地址。

    为什么

    内存地址的计算方法

    先看一段伪代码。这段伪代码是f函数的对应的汇编代码。假设f有三个参数。当然f也可以有四个参数或2个参数。我们用三个参数的情况来观察一下f。

    f:

     ; 入栈ebp

     ; 把ebp设置为esp

     

     ; ebp + 0 存储的是 eip，由call f入栈

     ; ebp + 4 存储的是 旧ebp

     ; 第一个参数是 ebp + 8

     ; 第二个参数是 ebp + 12

     ; 第三个参数是 ebp + 16

     

     ; 函数f的逻辑

     

     ; 出栈ebp。ebp恢复成了刚进入函数之前的旧ebp

     ; ret

    调用f的伪代码是：

    ; 入栈第三个参数

    ; 入栈第二个参数

    ; 入栈第一个参数

    ; 调用f，把eip入栈

    在汇编代码中，第一个参数的内存地址很容易确定，第二个、第三个还有第N个参数的内存地址也非常容易确定。无法是在ebp的基础上增加特定长度而已。

    可是，我们只能确定，必定存在第一个参数，不能确定是否存在的二个、第三个还有第N个参数。没有理由使用一个可能不存在的参数作为参照物、并且还要用它却计算其他参数的地址。

    第一个参数必定存在，所以，我们用它作为确定其他参数的内存地址的参照物。

    内存地址

    在f函数的C代码中，&fmt是第一个参数占用的f的栈的元素的内存地址，换句话说，是一个局部变量的内存地址。

    局部变量的内存地址不能作为函数的返回值，却能够在本函数执行结束前使用，包括在本函数调用的其他函数中使用。这就是在f2中仍然能够使用fmt计算出来的内存地址的原因。

    难点

    当参数是int类型时，获取参数的值使用*(int *)(next_arg)。

    当参数是char str[20]时，获取参数的值使用*(char **)(next_arg + 4)。

    为什么不直接使用next_arg、(next_arg + 4)呢？

    分析*(int *)(next_arg)。

    在32位操作系统中，任何内存地址的值看起来都是一个32位的正整数。可是这个正整数的值的类型并不是unsigned int，而是int *。

    关于这点，我们可以在gdb中使用ptype确认一下。例如，有一小段代码int *a;*a = 5;，执行ptype a，结果会是int *。

    next_arg只是一个正整数，损失了它的数据类型，我们需要把数据类型补充进来。我们能够把这个操作理解成”强制类型转换“。

    至于*(int *)(next_arg)前面的*，很容易理解，获取一个指针指向的内存中的值。

    用通用的方式分析*(char **)(next_arg+4)。

    1. 因为是第三个参数，因此next_arg+4。
    2. 因为第三个参数的数据类型是char str[20]。根据经验，char str[20]对应的指针是char *。
    3. 因为next_arg+4只是函数的栈的元素的内存地址，在目标元素中存储的是一个指针。也就是说，next_arg+4是一个双指针类型的指针。它最终又指向字符串，根据经验，next_arg+4的数据类型是char **。没必要太纠结这一点。自己写一个简单的指向字符串的双指针，使用gdb的ptype查看这种类型的数据类型就能验证这一点。
    4. 最前面的*，获取指针指向的数据。

    给出一段验证第3点的代码。

    char str[20] = "hello";
char *ptr = str;
// 使用gdb的ptype 打印 ptype &ptr

    打印结果如下：

    Breakpoint 1, main (argc=1, argv=0xffffd3f4) at point.c:13
    13  char str7[20] = "hello";
    (gdb) s
    14  char *ptr = str7;
    (gdb) s
    19  int b = 7;
    (gdb) p &str
    $1 = (char **) 0xffffd2fc

    优化

    在code-A和code-B中，我们人工根据参数的类型来获取参数，使用*(int *)(next_arg)或*(char **)(next_arg + 4)。

    库函数printf显然不是人工识别参数的类型。

    这个函数的第一个参数中包含%d、%x、%s等占位符。遍历第一个参数，识别出%d，就用*(int *)next_arg替换%d。识别出

    %s，就用*(char **)next_arg。

    实现了识别占位符并且根据占位符选择指针类型的功能，就能实现一个完成度很高的可变参数了。

    总结

    到此这篇关于C语言如何实现可变参数的文章就介绍到这了,更多相关C语言可变参数内容请搜索海外IDC网以前的文章或继续浏览下面的相关文章希望大家以后多多支持海外IDC网！

    更多阅读