目录
可变参数模版
C++11
的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含
固定数量
的模版参数，可变模版参数无疑是一个巨大的改
进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现
阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止，以后大
家如果有需要，再可以深入学习。
下面就是一个基本可变参数的函数模板:
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{
}
我们可以发现其实参数包就是将多个模版参数类型和参数都使用Args包装起来了,为了辨别与普通参数的区别,所以三个点是必要的;
上面的参数
args
前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为
“
参数
包
”
，它里面包含了
0
到
N
（
N>=0
）个模版参数。我们无法直接获取参数包
args
中的每个参数的，
只能通过
展开参数包的方式来获取参数包中的每个参数
，这是使用可变模版参数的一个主要特
点，也是最大的难点，即如何展开可变模版参数。由于语法
不支持使用args[i]这样方式
获取可变
参数，所以我们的用一些奇招来一一获取参数包的值。
获取参数包值的方式
1.递归方式展开参数包
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<functional>
using namespace std;
//结束递归函数
template<class T>
void ShowList(const T& value)//但最后只有一个参数时,调用该函数停止
{
cout << value << endl;
}
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
cout << value << " ";
ShowList(args...); //递归下一次,参数包中会分理出一个参数value;
}
int main()
{
//可以传任意多个参数
ShowList(1, "564", 5.4);
ShowList(1, 2, 5, 8, 4, 65, 6, 5);
return 0;
}参数包的优势就是参数不是固定的,可以随意的传递多个参数,递归是调用模版函数,每次都会从参数包中分出若干个参数使用;直到最后剩下的个数正好等于ShowList的使用参数个数(一个)时可传递参数时,就要手写一个停止的函数;
按照这样的方式,当然,也可以一次从参数包中分离出多个参数使用,但是最后要确保参数包中的参数要没有剩余;
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<functional>
using namespace std;
//结束递归函数
template<class T,class R>
void ShowList(T& val1,R& val2 )//但最后只有两个参数时(参数包没有剩余时),调用该函数停止
{
cout << val1 << " " << val2 << endl;
cout << "结束了" << endl;
}
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class T, class R,class ...Args>
void ShowList(T value1,R value2 ,Args... args)//可以一次分裂出多个参数使用,但是要确保最后参数包没有多余的参数
{
cout << value1 << " "<<value2<<" ";
ShowList(args...); //递归下一次,参数包中会分理出两个参数value;
}
int main()
{
//上面的函数依次使用了两个参数,所以实参必须是2的倍数
ShowList(1, "564", 5.4,8);
ShowList(1, 2, 5, 8, 4, 65, 6, 5);
return 0;
}
运行结果:
;除了这种方法之外,还可以使用数组结合逗号表达式来一次性使用所有的参数;
2.使用数组+逗号表达式展开
这种展开参数包的方式，不需要通过递归终止函数，是直接在
expand
函数体中展开的
, printarg
不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式
实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand
函数中的逗号表达式：
(printarg(args), 0)
，
也是按照这个执行顺序，先执行
printarg(args)，再得到逗号表达式的结果0
。同时还用到了
C++11
的另外一个特性
——
初始化列
表，
通过初始化列表来初始化一个变长数组
, {(printarg(args), 0)...}
将会展开成
((printarg(arg1),0),
(printarg(arg2),0), (printarg(arg3),0), etc... )
，最终会创建一个元素值都为
0
的数组int arr[sizeof...
(Args)]
。
由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)
打印出参数，也就是说在构造int数组的过程中就将参数包展开了
，这个数组的目的纯粹是为了在
数组构造的过程展开参数包;
template<class T >
void print(T value) //每次调用函数都会分离出一个参数
{
cout << value << " ";
}
template<class ...Args>
void ShowList(Args... args)
{
int arr[] = { (print(args),0)... }; //使用逗号表达式,间接的执行函数;
return;
}
int main()
{
ShowList("456", 2, 45, 616 );
return 0;
}emplace_back函数
STL
容器中的
empalce
相关接口函数：
http://www.cplusplus.com/reference/vector/vector/emplace_back/
http://www.cplusplus.com/reference/list/list/emplace_back/
template <class... Args>
void emplace_back (Args&&... args);
首先我们看到的
emplace
系列的接口，支持模板的可变参数，并且万能引用。那么相对
insert
和
emplace
系列接口的优势到底在哪里呢？
int main()
{
std::list< std::pair<int, char> > mylist;
// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
mylist.emplace_back(10, 'a');
mylist.emplace_back(20, 'b');//可以直接传模版类型;
mylist.emplace_back(make_pair(30, 'c'));//否则就需要传递list的变量
mylist.push_back(make_pair(40, 'd'));
mylist.push_back({ 50, 'e' });//列表初始化构造pair
for (auto e : mylist)
cout << e.first << ":" << e.second << endl;
return 0;
}以上面的代码为例,如果我们尾插节点,通常是需要先构造pair类型的变量,然后再尾插;C++11出来后由于列表初始化的出现,使用{}可以自动调用构造函数初始化,极大地方便了我们;但是除此之外;可变参数包的使用,使得emplace_back可以直接传递pair的参数就可以自动按照顺序调用构造;类似与上面一次使用多个参数的情况;
注意:emplace_back与push_back都只能依次尾插一个节点;
lambda表达式
C++98中的例子
在
C++98
中，如果想要对一个数据集合中的元素进行排序，可以使用
std::sort
方法;
int main()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较，排出来结果是升序
std::sort(array, array + sizeof(array) / sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}其中需要注意的就是greater是个仿函数;
这里补充下仿函数的知识:
什么是仿函数?
仿函数实质上是一个重载了括号的模版类;通常适用于比较自定义类型的大小,按照某一特性进行排序的方法;
上述代码的仿函数可以这样实现;
template<class T>
class _greater//为了避免与std中的冲突
{
public:
bool operator ()(T a, T b)
{
return a > b;
}
};
int main()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较，排出来结果是升序
std::sort(array, array + sizeof(array) / sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), _greater<int>());
for (auto& e : array)
cout << e << " ";
return 0;
}为什么要用仿函数,仿函数和普通的比较函数有什么区别?
答:1.灵活性和扩展性
普通比较函数：
普通比较函数的灵活性相对较低。它们只能执行静态的比较操作，并且不能存储状态或其他信息。
仿函数：
仿函数可以存储状态和其他成员变量，这使得它们在某些情况下比普通函数更强大。例如，你可以使用仿函数来维护计数器或其他状态信息：
class CompareWithCount {
public:
CompareWithCount() : count(0) {}
bool operator()(int a, int b) {
++count;
return a < b;
}
int getCount() const { return count; }
private:
int count;
};
在这种情况下，你可以在排序操作后检查比较操作的次数：
CompareWithCount comp;
std::sort(arr, arr + size, comp);
std::cout << "Number of comparisons: " <<comp.getCount() << std::endl;2.性能和优化
普通比较函数：
普通比较函数通常会有较少的开销，因为它们没有对象的创建和销毁开销，也没有成员变量的存储。
仿函数：
仿函数可以在编译时内联，因此在某些情况下，它们可以比普通函数更高效，尤其是当仿函数的 operator() 被内联时。此外，仿函数的成员变量可以在执行时保持状态，这在某些复杂的操作中可能提供性能优势。
如果待排序元素为自定义类型，需要用户定义排序时的比较规则:
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
}
随着
C++
语法的发展，
人们开始觉得上面的写法太复杂了，每次为了实现一个
algorithm
算法，
都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便
。因此，在
C++11
语法中出现了
Lambda
表达式;
lambda表达式
先展示下lambda表达式的使用;
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._evaluate < g2._evaluate; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._evaluate > g2._evaluate; });
}
上述代码就是使用
C++11
中的
lambda
表达式来解决，可以看出
lambda
表达式实际是一个匿名函
数。
语法
ambda
表达式书写格式：
[capture-list] (parameters) mutable -> return-type { statement
}
1. lambda
表达式各部分说明
[capture-list] :
捕捉列表
，该列表总是出现在
lambda
函数的开始位置，
编译器根据
[]
来
判断接下来的代码是否为
lambda
函数
，
捕捉列表能够捕捉上下文中的变量供
lambda
函数使用,是不可以省略的
。
(parameters)
：参数列表。与
普通函数的参数列表一致
，如果不需要参数传递，则可以
连同
()
一起省略
mutable
：默认情况下，
lambda
函数总是一个
const函数
，
mutable
可以取消其常量
性。使用该修饰符时，
参数列表不可省略
(
即使参数为空
)。
->returntype
：返回值类型
。用
追踪返回类型形式声明函数的返回值类型
，
没有返回
值时此部分可省略
。
返回值类型明确情况下，也可省略，由编译器对返回类型进行推
导
。
{statement}
：函数体
。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
到的变量。
注意：
在
lambda
函数定义中，
参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空
。因此
C++11
中
最简单的
lambda
函数为：
[]{...}
;
该
lambda
函数不能做任何事情。
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[] {};
// 省略参数列表和返回值类型，返回值类型由编译器推导为int
int a = 3, b = 4;
[=] {return a + 3; };//[=]捕捉(=就是拷贝)所有之前出现的变量;可以在函数体使用;
// 省略了返回值类型，无返回值类型
auto fun1 = [&](int c) {b = a + c; };
fun1(10);
cout << a << " " << b << endl;
// 各部分都很完善的lambda函数
auto fun2 = [=, &b](int c)->int {return b += a + c; };
cout << fun2(10) << endl;
// 复制捕捉x
int x = 10;
//需要使用mutable才能改变拷贝的x;
auto add_x = [x](int a) mutable { x *= 2; return a + x; };
cout << add_x(10) << endl;
return 0;
}
通过上述例子可以看出，
lambda
表达式实际上可以理解为无名函数，该函数无法直接调
用，如果想要直接调用，可借助
auto将其赋值给一个变量;
捕获列表说明
捕捉列表描述了上下文中那些数据可以被
lambda
使用
，以及
使用的方式传值还是传引用
。
[var]
：表示值传递方式捕捉变量
var
[=]
：表示值传递方式捕获所有父作用域中的变量
(
包括
this)
[&var]
：表示引用传递捕捉变量
var
[&]
：表示引用传递捕捉所有父作用域中的变量
(
包括
this)
[this]
：表示值传递方式捕捉当前的
this
指针
注意：
a.
父作用域指包含
lambda
函数的语句块
b.
语法上捕捉列表可由多个捕捉项组成，并以逗号分割
。
比如：
[=, &a, &b]
：以引用传递的方式捕捉变量
a
和
b
，值传递方式捕捉其他所有变量[&，
a, this];
值传递方式捕捉变量
a
和
this
，引用方式捕捉其他变量
c.
捕捉列表不允许变量重复传递，否则就会导致编译错误
。
比如：
[=, a]
：
=
已经以值传递方式捕捉了所有变量，捕捉
a
重复
d.
在块作用域以外的
lambda
函数捕捉列表必须为空
。
e.
在块作用域中的
lambda
函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量会导致编译报错。
f.
lambda
表达式之间不能相互赋值
，即使看起来类型相同
void (*PF)();
int main()
{
auto f1 = []{cout << "hello world" << endl; };
auto f2 = []{cout << "hello world" << endl; };
// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
//f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个lambda表达式拷贝构造一个新的副本
auto f3(f2);
f3();
// 可以将lambda表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}lambda表达式和函数比较
函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了
operator()
运算符的
类对象。
class Rate
{
public:
Rate(double rate): _rate(rate)
{}
double operator()(double money, int year)
{ return money * _rate * year;}
private:
double _rate;
};
int main()
{
// 函数对象
double rate = 0.49;
Rate r1(rate);
r1(10000, 2);
// lamber
auto r2 = [=](double monty, int year)->double{return monty*rate*year;
};
r2(10000, 2);
return 0;
}
从使用方式上来看，函数对象与
lambda
表达式完全一样。
函数对象将
rate
作为其成员变量，在定义对象时给出初始值即可，
lambda
表达式通过捕获列表可
以直接将该变量捕获到。
实际在底层编译器对于
lambda
表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个
lambda
表达式，编译器会自动生成一个类，在该类中重载了
operator()
。
包装器
function包装器
function
包装器 也叫作适配器。
C++
中的
function
本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function
呢？
ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
为什么呢？我们继续往下看
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;
return 0;
}
通过上面的程序验证，我们会发现
useF
函数模板实例化了三份。
包装器可以很好的解决上面的问题
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
// 使用方法如下：以加法为例
#include <functional>
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
static int plusi(int a, int b)//静态函数
{
return a + b;
}
double plusd(double a, double b)//成员函数
{
return a + b;
}
};
int main()
{
// 函数名(函数指针)
std::function<int(int, int)> func1 = f;
cout << func1(1, 2) << endl;
// 函数对象
std::function<int(int, int)> func2 = Functor();
cout << func2(1, 2) << endl;
// lamber表达式
std::function<int(int, int)> func3 = [](const int a, const int b)
{return a + b; };
cout << func3(1, 2) << endl;
// 类的成员函数
std::function<int(int, int)> func4 = &Plus::plusi;
cout << func4(1, 2) << endl;
std::function<double(Plus, double, double)> func5 = &Plus::plusd;//包装成员函数需要多一个参数Plus(隐含的this)
cout << func5(Plus(), 1.1, 2.2) << endl;
return 0;
}
有了包装器，如何解决模板的效率低下，实例化多份的问题呢？
#include <functional>
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
std::function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function<double(double)> func3 = [](double d)->double{ return d /
4; };
cout << useF(func3, 11.11) << endl;
return 0;
}
包装器的其他一些场景：
https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/submissions/
bind绑定器
std::bind
函数定义在头文件中，
是一个函数模板，它就像一个函数包装器
(
适配器
)
，
接受一个可
调用对象（
callable object
），生成一个新的可调用对象来
“
适应
”
原对象的参数列表
。一般而
言，我们用它可以把一个原本接收
N
个参数的函数
fn
，通过绑定一些参数，返回一个接收
M
个（
M
可以大于
N
，但这么做没什么意义）参数的新函数。同时，使用
std::bind
函数还可以实现参数顺
序调整等操作。
// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
可以将
bind
函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对
象来
“
适应
”
原对象的参数列表。
调用
bind
的一般形式：
auto newCallable = bind(callable,arg_list);
其中，
newCallable
本身是一个可调用对象，
arg_list
是一个逗号分隔的参数列表，对应给定的
callable
的参数。
当我们调用
newCallable
时，
newCallable
会调用
callable,
并传给它
arg_list
中
的参数
。
arg_list
中的参数可能包含形如
_n
的名字，其中
n
是一个整数，这些参数是
“
占位符
”
，表示newCallable的参数，它们占据了传递给
newCallable
的参数的
“
位置
”
。数值
n
表示生成的可调用对
象中参数的位置：
_1为newCallable的第一个实参，_2为第二个实参，
以此类推;
// 使用举例
#include <functional>
int Plus(int a, int b)
{
return a + b;
}
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,
placeholders::_2);
//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
//func2的类型为 function<void(int, int, int)> 与func1类型一样
//表示绑定函数 plus 的第一，二为： 1， 2
auto func2 = std::bind(Plus, 1, 2);
cout << func1(1, 2) << endl;
cout << func2() << endl;
Sub s;
// 绑定成员函数
std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,
placeholders::_1, placeholders::_2);
// 参数调换顺序
std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,
placeholders::_2, placeholders::_1);
cout << func3(1, 2) << endl; //1-2
cout << func4(1, 2) << endl;//2-1
return 0;
}注意:为了方便使用,可以以using placeholders::_1的形式使用;
扫一扫
8291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
