C/C++编程：va_list实现可变参数

女爷i 2022-12-24 05:56 146阅读 0赞

# 理论 #

## 变常参数的宏定义以及`__VA_ARGS` ##

变长参数的宏定义是指在宏定义中参数列表的最后一个参数为省略号，而预定义宏`__VA_ARGS`则可以在宏定义的实现部分替换省略号所代表的字符串，比如：

#define PR(...) printf(__VA_ARGS__)

就可以定义一个printf的别名PR。实际上，变长参数宏与printf经常搭配使用：

#include <stdio.h>
    
    #define LOG(...){ \
        fprintf(stderr, "%s: Line %d:\t", __FILE__, __LINE__);\
        fprintf(stderr, __VA_ARGS__);\
        fprintf(stderr, "\n");\
    }
    
    int main()
    {
        
        LOG("test : %d", 3);
        return 0;
    }

![在这里插入图片描述][2021042817193328.png]

## va\_list ##

头文件：

<stdarg.h>

作用：

> 保存va\_start，va\_arg，va\_end和va\_copy（typedef）所需的信息

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>va_start</td> 
   <td>允许访问可变参数函数参数</td> 
  </tr> 
  <tr> 
   <td>va_arg</td> 
   <td>访问下一个可变参数函数参数</td> 
  </tr> 
  <tr> 
   <td>va_copy</td> 
   <td>制作可变参数函数参数（函数宏）的副本</td> 
  </tr> 
  <tr> 
   <td>va_end</td> 
   <td>结束可变参数函数参数（函数宏）的遍历</td> 
  </tr> 
 </tbody> 
</table>

当你的函数的参数个数不确定时，就可以使用上述宏进行动态处理，这无疑为你的程序增加了灵活性。

va\_list的使用方法：

*  首先在函数中定义一个具有va\_list型的变量，这个变量是指向参数的指针。
 *  然后用va\_start宏初始化变量刚定义的va\_list变量，使其指向第一个可变参数的地址。
 *  然后va\_arg返回可变参数，va\_arg的第二个参数是你要返回的参数的类型（如果多个可变参数，依次调用va\_arg获取各个参数）。
 *  最后使用va\_end宏结束可变参数的获取。

在使用va\_list是应该注意一下问题：

*  可变参数的类型和个数完全由代码控制，它并不能智能地识别不同参数的个数和类型。
 *  如果我们不需要一一详解每个参数，只需要将可变列表拷贝到某个缓冲区，可以用vsprintf函数。
 *  因为编译器对可变参数的函数原型检查不够严格，对编程查错不利，不利于我们写出高质量的代码。

## 原理 ##

typedef char *va_list;

va\_start宏，获取可变参数列表的第一个参数的地址（list是类型为va\_list的指针，param1是可变参数最左边的参数）：

#define va_start(list,param1)   ( list = (va_list)&param1+ sizeof(param1) )

va\_arg宏，获取可变参数的当前参数，返回指定类型并将指针指向下一参数（mode参数描述了当前参数的类型）：

#define va_arg(list,mode)   ( (mode *) ( list += sizeof(mode) ) )[-1]

va\_end宏，清空va\_list可变参数列表：

#define va_end(list) ( list = (va_list)0 )

假设有这样一个函数

void test(char *para1，char *param2，char *param3, char *param4)
    {
        
          va_list list;
          ......
          return;
    }

在c语言中，函数参数是存储在栈中的，函数参数从右到左依次入栈。又Linux中，栈地址从高到低生长。因此，调用`test`函数时，其参数入栈情况如下：  
![在这里插入图片描述][20201127092835228.png_pic_center]  
调用`va_start(list, param1)`时，`list`指针指向情况如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]  
最复杂的宏是va\_arg。它必须返回一个由va\_list所指向的恰当的类型的数值，同时递增va\_list，使它指向参数列表中的一个参数(即递增的大小等于与va\_arg宏所返回的数值具有相同类型的对象的长度)。因为类型转换的结果不能作为赋值运算的目标，所以va\_arg宏首先使用sizeof来确定需要递增的大小，然后把它直接加到va\_list上，这样得到的指针再被转换为要求的类型。因为该指针现在指向的位置"过"了一个类型单位的大小，所以我们使用了下标-1来存取正确的返回参数。

# 实践 #

## 基本用法 ##

#include <stdio.h>
    #include <stdarg.h>
    
    
    void simple_printf(const char *fmt, ...){
        
        va_list  args;   //  //定义一个具有va_list型的变量，这个变量是指向参数的指针。
        va_start(args, fmt);  // 第一个参数指向可变列表的地址,地址自动增加
    
        while (*fmt != '\0'){
        
            if (*fmt == 'd'){
        
                int i = va_arg(args, int );  //  访问下一个可变参数函数参数
                printf("%d\n", i);
            } else if (*fmt == 'c'){
        
                int c = va_arg(args, int);
                printf("%c\n", c);
            }else if (*fmt == 'f') {
        
                double d = va_arg(args, double);
                printf("%f\n", d);
            }
            ++fmt;
        }
    }
    
    int main(){
        
        simple_printf("dcff", 3, 'a', 1.99, 425.5);
    }

![在这里插入图片描述][20201127090814115.png_pic_center]

#include <stdio.h>
    #include <stdarg.h>
    #include <cmath>
    
    
    double stddev(int count, ...){
        
        double sum = 0;
        double sum_sq = 0;
        va_list  args;
        va_start(args, count);
        for (int i = 0; i < count; ++i) {
        
            double num = va_arg(args, double );
            sum += num;
            sum_sq += num * num;
        }
        va_end(args);
        return  sqrt(sum_sq/count - (sum/count)*(sum/count));
    }
    
    int main(){
        
        printf("%f\n", stddev(4, 25.0, 27.3, 26.9, 25.7));
    }

![在这里插入图片描述][20201127091318244.png_pic_center]

#include <stdio.h>
    #include <stdarg.h>
    
    
    double stddev(int count, ...){
        
        double sum = 0;
        va_list  args1, args2;
        va_start(args1, count);
        va_copy(args2, args1);
        for (int i = 0; i < count; ++i) {
        
            double num = va_arg(args1, double);
            sum += num;
        }
        for (int i = 0; i < count; ++i) {
        
            double num = va_arg(args2, double);
            sum += num;
        }
    
    
        va_end(args1);
        return sum;
    }
    
    int main(){
        
        printf("%f\n", stddev(4, 25.0, 27.3, 26.9, 25.7));
    }

![在这里插入图片描述][20201127091736446.png_pic_center]

#include  <stdio.h>
    #include  <stdarg.h>
    
    void error(char *format, ...)
    {
        
        va_list ap;
        va_start(ap, format);
        fprintf(stderr, "Error: ");
        vfprintf(stderr, format, ap);
        va_end(ap);
        fprintf(stderr, "\n");
        return;    
    }

#include <stdio.h>
    #include <stdarg.h>
    #include <string.h>
    void acl_msg_printf(const char *fmt,...){
        
        char buf[2048];
        va_list ap;
    
        va_start (ap, fmt);
        vsnprintf(buf, sizeof(buf), fmt, ap);
        printf("%s\r\n", buf);
    
    
        va_end(ap);
    }
    
    int main(){
        
        acl_msg_printf("%s %d %s", "Failed", 100, "times");
    }

![在这里插入图片描述][20201207092630289.png]

#include <stdio.h>
    #include <stdarg.h>
    #include <string.h>
    void acl_msg_error(char *format, ...)
    {
        
        va_list ap;
        va_start(ap, format);
        fprintf(stderr, "Error: ");
        vfprintf(stderr, format, ap);
        va_end(ap);
        fprintf(stderr, "\n");
        return;
    }
    
    int main(){
        
        acl_msg_error("%s %d %s", "Failed", 100, "times");
    }

![在这里插入图片描述][20201207092611649.png]

include <cstdio>
    #include <cstdarg>
    #include <cstring>
    #include <memory>
    #include <string>
     
    std::string str_format(const char *fmt, ...)
    {
        
        int old_size = strlen(fmt);
        std::unique_ptr<char[]> buf(new char[old_size]);
        va_list ap;
         
        va_start(ap, fmt);
        int new_size = vsnprintf(buf.get(), old_size, fmt, ap);
        va_end(ap);
        if (new_size < 0)
            return "";
     
        buf.reset(new char[new_size + 1]);
        va_start(ap, fmt);
        new_size = vsnprintf(buf.get(), new_size + 1, fmt, ap);
        va_end(ap);
        if (new_size < 0)
            return "";
     
        return std::string(buf.get());
    }
     
    int main()
    {
        
        auto ret = str_format("%d %lf %s", 1, 3.14, "hello world");
        printf("%s\n", ret.c_str());  // 1 3.140000 hello world
        return 0;
    }

[2021042817193328.png]: /images/20221120/bc779e816a8244d7a7ad9da0c4f24faa.png
[20201127092835228.png_pic_center]: /images/20221120/7535f18ee7b241549a8e9801fc5b0030.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/a8c10cff1c1f4c04b5f133312fdeebcd.png
[20201127090814115.png_pic_center]: https://img-blog.csdnimg.cn/20201127090814115.png#pic_center
[20201127091318244.png_pic_center]: https://img-blog.csdnimg.cn/20201127091318244.png#pic_center
[20201127091736446.png_pic_center]: https://img-blog.csdnimg.cn/20201127091736446.png#pic_center
[20201207092630289.png]: https://img-blog.csdnimg.cn/20201207092630289.png
[20201207092611649.png]: https://img-blog.csdnimg.cn/20201207092611649.png