您现在的位置是:首页 >学无止境 >C++ 折叠参数包:悄然增强编程效率网站首页学无止境
C++ 折叠参数包:悄然增强编程效率
前言
欢迎来到?小K?的?C++专栏?,本节将为大家带来折叠参数包的详细讲解,折叠参数包为C++模板编程提供了更加灵活和强大的工具,可以提高代码的简洁性和可读性,看完后希望对你有收获
一、介绍
折叠参数就是一个参数包, 代表是多个未知,tuple元组就是一个折叠参数的使用
折叠参数类型:
typename ...Args:
Args参数包的包名 ,本质是声明一个Args折叠参数类型Args ...arg:
折叠参数包类型的变量...:
理解为多个意思
二、函数模板中使用折叠参数
1、递归方式展开
递归方式的展开是比较好理解的,每一次调用第二个print函数就打印一次data,然后又调用自己,这时候参数包也剥离了一个参数,也就是调用自己会打印下一个data
有的同学看了下面的代码可能会疑惑,为什么会有两个函数,这是因为上面的函数为终止函数,也就是当第二个函数参数包中只有一个参数时调用第一个函数
template <typename _Ty>
void print(_Ty data)
{
cout << data << endl;
}
template <typename _Ty,typename ...Args>
void print(_Ty data, Args ...args)
{
cout << data << " ";
print(args...);
}
2、列表数据展开
这个的难点和重点在于initializer_list<int>{(printData(args), 0)...};
,这一行代码用到了列表和逗号表达式的特性,不用说列表的每个值最后都被初始化为0,但是列表的每个值被初始化为0的时候,他们会先执行printData(args(n))
,也就是会不断打印,参数包不断展开
template <typename _Ty>
void printData(_Ty data) {
cout << data << " ";
}
template <typename ...Args>
void printArgs(Args ...args)
{
initializer_list<int>{(printData(args), 0)...};
cout << endl;
}
3、完美转发的方式展开
完美转发一般是用来统一接口,也就是有许多函数,他们的参数数量、类型不同,我们把他们统一为只用函数名就可以调用该函数,且不减少其原功能
这里我们用仿函数接收一下用bind绑定的函数以及参数包,注意这里函数和参数包绑定的时候都用了完美转发
什么是完美转发呐?forword是为了解决在函数模板中,使用右值引用参数(T&&),传递右值进去以后,类型会变为左值的问题。当传入的参数是一个对象时,右值变左值就会出问题,因为左值调用拷贝构造,右值调用移动构造。本来可以用移动构造提高效率,却因为右值变成左值,调用了拷贝构造。所以我们要把它变回去!实参传的是右值,进入函数体还是右值,这就是完美转发
class Test
{
public:
void printk()
{
if (func) func();
}
template <typename Func,typename ...Args>
void connect(Func&& f, Args&& ...args) //右值引用
{
func = bind(forward<Func>(f), forward<Args>(args)...);
}
protected:
function<void()> func;
};
void sum(int a, int b)
{
cout<< a + b;
}
int main()
{
Test test;
test.connect(sum, 1, 2);
test.printk();
test.connect([](int a, int b) {cout << endl << a + b; }, 3, 8);
test.printk();
return 0;
}
上面的例子中通过connect
绑定函数和参数包,实现统一接口的功能,通过printK
函数调用
三、类模板中使用折叠参数
1、继承+模板特化的方式展开
类中实现折叠参数,前两个类是必须,对应上面的终止函数,继承的时候要写清楚public Test<Args...>
,还有就是第三个类必须要一个无参构造函数,且带参数包的的构造函数初始化时要调用子类的构造函数,还有就是打印的时候要一层一层的,采用继承+模板特化就是一代一代的
template <typename ...Args>
class Test;
template<>
class Test<> {};
template <typename _Ty, typename ...Args>
class Test<_Ty, Args...> :public Test<Args...>
{
public:
Test() {}
Test(_Ty data, Args ...args) :data(data), Test<Args...>(args...) {}
Test<Args...>& getObject() { return *this; }
_Ty& getData() { return data; }
protected:
_Ty data;
};
void testOne()
{
Test<string, int, double> test("fsdjf", 32, 3.23);
cout << test.getData() << " " << test.getObject().getData() << " " << test.getObject().getObject().getData() << endl;
}
2、递归的方式展开
递归这一种就是把自己当对象调用,其它的和上面相同
template <typename ...Args>
class my_tuple;
template<>
class my_tuple<> {};
template <typename _Ty, typename ...Args>
class my_tuple<_Ty, Args...>
{
public:
my_tuple() {}
my_tuple(_Ty data, Args ...args) :data(data),args(args...) {}
_Ty& getData() { return data; }
my_tuple<Args...>& getObject() { return *this; }
protected:
_Ty data;
my_tuple<Args...> args;
};
void testTwo()
{
Test<string, int, double> test("fsdjf", 32, 3.23);
cout << test.getData() << " " << test.getObject().getData() << " " << test.getObject().getObject().getData() << endl;
}