C++可变参数使用总结

2023-06-22 109

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： C++可变参数使用总结

可变参数是指函数可以接受不定数量的参数。比如在printf函数，如果做日志等功能也会用到。这里总结下可变参数的使用。

c语言中的可变参数

先介绍下在c语言中的使用，c语言也支持可变参数，只是需要借助下va_list和va_arg宏解析。

使用方式一

//省略符形参应该仅仅用于C和C++通用的类型
int sum(int count, ...){
    if (count <= 0)
  {
    return 0;
  }
  //为了实现可变参数列表，首先需要声明一个va_list类型的指针
  //va_list类型是在cstdarg头文件里面定义的，该指针用来依次指向各个参数
  //va_start是一个宏，用来初始化arg_ptr，使其指向列表的第一个参数，这个宏的第二个参数是sum函数参数列表省略号前得固定参数的名称，用来确定第一个参数的位置    
  va_list arg_ptr;
  va_start(arg_ptr, count);
  int CountSum = 0;
  //va_arg是一个宏，返回arg_ptr指向的参数位置，并使arg_ptr递增来指向下一个参数值
  //va_arg宏的第二个参数是需要统计的第一个参数的类型，如果类型不正确，
  //程序也可能会执行，但得到的是无用的数据，arg_ptr将被错误地递增
  for (int i = 0; i < count; ++i)
  {
    CountSum += va_arg(arg_ptr, int);
  }
  //将va_list类型的指针复位成空值就是清空可变参数列表
  va_end(arg_ptr);
  return CountSum;
}
//....
sum(5,1,2,3,4,5);//return 15

使用方式二

宏定义，__VA_ARGS__ 就表示可变参数列表；

#define debug(...) print(cout,__VA_ARGS__)
#define debug2(os, ...) print(os, __VA_ARGS__)
//#define debug2(format, args...) print(format, ##args)//win32不支持
debug2(cout,"this ", " year");//"this  year"

c++模板可变参数

模板可变参数使用格式定义，举例如下：

template<typename T, typename... Args>
void foo(const T& t, const Args&... rest) {
  std::cout << sizeof(T) << endl;
  cout << sizeof...(Args) << endl;//打印可变参数数量
  cout << sizeof...(rest) << endl;//打印可变参数数量
}

如何一个一个的打印出参数？在c++之前，这里有个递归的实现方法。在c++17之后，也可以不用递归，有更简单的写法，可以使用c++17提供的折叠表达式fold expression，让我们处理变参更简单，代码也会变得更加简洁。注折叠表达式用法只能在c++17及以上的编译环境下使用，否则会收到如下编译错误：

main.cpp: In function ‘int foo(Args ...)’:
main.cpp:21:26: warning: fold-expressions only available with ‘-std=c++17’ or ‘-std=gnu++17’
   21 |     return (foo1(args) + ...);
      |                          ^~~

先介绍下递归的实现方法：

//2个参数时 比后者更特例化，会优先匹配此函数，
//必须写在前面，不然会递归编译到print(ostream& os）从而编译错误
template<typename T, typename... Args>
ostream& print(ostream& os, const T& t) {
  return os << t << ", ";
}
template<typename T,typename... Args>
ostream& print(ostream& os, const T& t, const Args&... rest) {
  os << t << ", ";
  return print(os, rest...);
}
print(cout,1,2,"haha");//"1, 2, haha"

c++17的fold expression的实现方法：

#include <iostream>
using namespace std;
template<typename T,typename... Args>
ostream& print(ostream& os, const T& t, const Args&... rest) {
  os << t;
  ((os << ","<<rest),...);
  os << "\n";
  return os;
}
int main()
{
    cout<<"Hello World\n";
    print(cout,1,2,"haha");//"1, 2, haha"
    return 0;
}

泛型lambda表达式

template<typename T>
int foo1(T t)
{
    return t;
}
template <typename... Args>
int foo(Args ...args)
{
    return (foo1(args) + ...);
}
void TestCpp17(std::string a,std::string b)
{
    auto f1 = []<typename T, typename N>(T t, N n)-> T {
        return t + n;
    };
    auto f2 = []<typename ...T>(T && ...args) {
        return foo(std::forward<T>(args)...);
    };
    std::string s = f1(a,b);
    std::cout << "string is:" << s << std::endl;
    int d = f2(1,2,3,6);
    std::cout << "result is:" << d << std::endl;
}
int main()
{
    std::string s1 = "123";
    std::string s2 = "321";
    std::string ss = s1 + s2;
    TestCpp17(s1,s2);
    return 0;
}

可变参数模板

以下示例仅在c++17之后可用。使用了可变参数模板，使得overloaded可以继承自多个Lambda。其次使用了Using-declaration，以防止重载之时产生歧义。类模板实参推导 (CTAD)，C++17的CTAD(Class Template Argument Deduction)，以推导出overloaded的类型。这样做的目的，就是通过CTAD为overloaded添加一个用户自定义的类型推导指引，从而让编译器可以推导lambda的类型，进而可以创建出overloaded类型的对象。

#pragma once
#include <iostream>
//可变参数模板
template < typename ... Ts > 
struct Animal:Ts ... 
{
  //使用Using-declaration，以防止重载之时产生歧义
  using Ts::operator () ...;
};
//c++17的类模板实参推导 (CTAD)
template < typename ... Ts > 
Animal (Ts ...)->Animal < Ts ... >;
struct Pig { void display() { std::cout << "is pig" << std::endl; } };
struct Horse { void display() { std::cout << "is horse"<< std::endl; } };
// 定义
static constexpr auto Factory = Animal{
 []<typename T>(const T& t) { return new T; }
 };
void TestFactory()
{
    auto pig = Factory(Pig{});
    pig->display();
}
int main()
{
    TestFactory();
    return 0;
}

可变参数initializer_list

这种方式局限性很大，列表里只能同类型，他的用法跟传vector参数类似，但是比vector跟轻量，而且元素是常量。

//initializer_list相对vector更轻量化 而且元素是常量
void error_msg(initializer_list<string> il) {
  for (auto beg = il.begin(); beg != il.end(); ++beg)
    cout << *beg << " ";
  cout << endl;
}
error_msg({"im","da","gong"});//"im da gong"