C++11
- 统一的列表初始化
- ｛｝初始化
- std::initializer_list
- 声明
- auto
- decltype
- nullptr
- STL中一些变化
- 新容器
- 已有容器的新接口
- 右值引用和移动语义
- 左值引用和右值引用
- 右值引用使用场景和意义
- 右值引用引用左值及其一些更深入的使用场景分析
- 完美转发
- 新的类功能
- 默认成员函数
- default与delete
- 可变参数模板
- 参数包
- 遍历参数包中的参数
- STL容器中的empalce相关接口函数
- lambda表达式
- 为什么要有lambda表达式
- lambda表达式的格式
- lambda的底层
- 包装器
- function包装器
- bind
统一的列表初始化
｛｝初始化
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
#include<iostream>
using namespace std;
int main()
{
int arr1[] = { 1,2,3,4,5,6 };
int arr2[]{ 1,2,3,4,5,6 };
for (auto e : arr1)
{
cout << e << " ";
}
cout << endl;
for (auto e : arr2)
{
cout << e << " ";
}
cout << endl;
return 0;
}
#include<iostream>
using namespace std;
struct Point
{
int _x;
int _y;
};
int main()
{
Point* p1 = new Point[2]{ {1,1},{2,2} };
return 0;
}
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{
cout << "Date(int year, int month, int day)" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//这三个效果是相同的
Date d1(2023, 5, 25);
Date d2{ 2023, 5, 25 };
Date d3 = { 2023, 5, 25 };
return 0;
}
也就是说这里用花括号进行初始化调用的是类的构造。
也就是说，C++11几乎可以一切都可以用花括号初始化，包括变量（但是不建议这样）。
std::initializer_list
来看下面这段代码：
#include<iostream>
#include<vector>
#include<list>
using namespace std;
int main()
{
vector<int> arr{1, 2, 3, 4, 5, 6};//这里的初始化为什么可以随意改变元素数量呢？
auto a = { 10,20,30 };//来看看这个花括号初始化成了什么类型
cout << typeid(a).name() << endl;//这里拿到的是类型的字符串
return 0;
}
这是initializer_list类型的使用文档https://cplusplus.com/reference/initializer_list/initializer_list/
这个类似一个常量数组，有两个指针指向数组的开始和结束（其实也是迭代器）。
并且这个vector可以利用这个类型进行初始化的。
其实就相当于将initializer_list类型中的数据遍历然后push_back()到vector里面。
这种类型的实用处就是：
//这里就不用初始化一个pair类型的然后在插入map中了，因为里面是匿名对象的初始化
map<string, string> str = { {"字符串","string"},{"排序","sort"} };//里面的两个小花括号也可以理解为一个pair类型的initializer_list数组
声明
auto
这个经常用，自动推导左边对象类型。
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局
部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将
其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初
始化值的类型。
decltype
关键字decltype将变量的类型声明为表达式指定的类型。
#include<iostream>
using namespace std;
int main()
{
int x = 0;
cout << typeid(x).name() << endl;
decltype(x) y;
cout << typeid(y).name() << endl;
return 0;
}
那么decltype使用的地方在哪里呢？
#include<iostream>
using namespace std;
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
decltype(t1 * t2) ret = t1 * t2;//这里万一涉及到整型提升，不知道提升到哪个类型就可以自动推导，不至于丢失精度
cout << typeid(ret).name() << endl;
cout << ret << endl;
}
int main()
{
F(1, 2);
F(1, 2.2);
return 0;
}
nullptr
这个之前也经常用。
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示
整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
STL中一些变化
新容器
array
https://legacy.cplusplus.com/reference/array/array/
这个新容器和数组的功能没什么区别，不如vector好用，比普通数组多一个越界检查的报错。
forward_list
https://legacy.cplusplus.com/reference/forward_list/forward_list/
这是个单链表。
这里的区别就是，每个节点少一个指针的大小，并且没有头插头删（并不是那么好用）
已有容器的新接口
这里以vector举例：
这四个其实就是上面的正迭代器和反迭代器，c只是为了显示是const版本的而已，看起来更容易辨别。
这个接口是缩容的接口，如果空间浪费的实在是太大，可以用一下（用时间换空间）。
还有这两个接口，与右值引用和可变模板参数有关，下面会结合这个接口讲解。
右值引用和移动语义
左值引用和右值引用
什么是左值？
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。
定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
什么是右值？
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
右值引用就是对右值的引用，给右值取别名。
注意：
- 左值引用只能引用左值，不能引用右值。
- 但是const左值引用既可引用左值，也可引用右值。
- 右值引用只能右值，不能引用左值。
- 但是右值引用可以move以后的左值。
#include<iostream>
using namespace std;
int main()
{
// 左值引用只能引用左值，不能引用右值。
int a = 10;
int& ra1 = a;//ra为a的别名
//int& ra2 = 10;//编译失败，因为10是右值
//const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
int a = 10;
int&& r2 = a;
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}
需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可
以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地
址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。
右值引用使用场景和意义
左值引用最大的意义就是函数传参，返回值，减少拷贝。
那么左值引用的缺点是什么？
看下面代码：
template<class T>
T func(const int x)
{
T ret;
return ret;//这里ret是局部变量，出作用域就会销毁，所以是一个传值返回
}
右值引用的价值之一就是补齐这最后一块短板。
右值引用引用左值及其一些更深入的使用场景分析
来看这样一段代码：
#include<iostream>
#include<cassert>
#include<algorithm>
using namespace std;
namespace baiye
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
//cout << "string(char* str)" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// s1.swap(s2)
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 深拷贝" << endl;
string tmp(s._str);
swap(tmp);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
//string operator+=(char ch)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
}
namespace baiye
{
baiye::string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
baiye::string str;
while (value > 0)
{
int x = value % 10;
value /= 10;
str += ('0' + x);
}
if (flag == false)
{
str += '-';
}
reverse(str.begin(), str.end());
return str;
}
}
int main()
{
baiye::string str = baiye::to_string(-1234);
return 0;
}
先看main函数中创建str然后调用to_string函数返回一个string类型赋值给str。
这里编译器优化就变成了拷贝构造。
这样就少了一次拷贝构造。
但如果是这种情况就无法进行优化。
那么这种情况下C++11是怎么解决问题的呢？
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
swap(s);
}
如果传的参数是右值就会走这个函数。
注意：C++11给右值分为
纯右值（内置类型）
将亡值（自定义类型）
那么在to_string函数中返回了一个将亡值，如果在进行拷贝构造有些没必要：
那么这里在进行拷贝传值的时候就会传给移动构造函数，移动构造函数内部其实就是交换两个对象的值，反正将亡值也要销毁了，这样就不用进行深拷贝了。（深拷贝代价太大，如果深拷贝的对象是vector<vector< int>>效率就非常低了）
但是刚才这种情况还没有解决：
那么这里就可以再写一个移动赋值：
// 移动赋值
string& operator=(string&& s)
{
swap(s);
return *this;
}
总结
右值引用是间接起作用，如果右值是将亡值，那么就转移资源。
这里用vector举例：如果传进去的是右值，就会走这个接口，会提升效率。
**注意：**右值引用被引用一次之后，引用的这个别名就变成了左值。
如果不变成左值怎么传给swap。
完美转发
万能引用
#include<iostream>
using namespace std;
template<class T>
void func(T&& x)//这里也可以称为引用折叠，如果传的是左值，就折叠成一个引用符号
{
}
int main()
{
int x = 10;
func(x);//左值也可以
func(2);//右值也可以
const int y = 20;
func(y);//const左值
func(move(y));//const右值
return 0;
}
那么这个时候如果func函数中要去调用这四个函数，结果是怎么样的呢？
#include<iostream>
using namespace std;
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
template<class T>
void func(T&& x)
{
Fun(x);
}
int main()
{
int x = 10;
func(x);//左值
func(2);//右值
const int y = 20;
func(y);//const左值
func(move(y));//const右值
return 0;
}
这里只会调用前两个函数，因为func中的参数x都是左值属性，这里就需要一个叫完美转发的在传参的过程中保持了 x 的原生类型属性。
新的类功能
默认成员函数
C++11 新增了两个默认成员函数：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
default与delete
强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原
因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以
使用default关键字显示指定移动构造生成。
#include<iostream>
using namespace std;
class Person
{
public:
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
Person(const Person& p)
:_name(p._name)
, _age(p._age)
{}
Person(Person && p) = default;//强制生成
private:
string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
return 0;
}
禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁
已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即
可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
#include<iostream>
using namespace std;
class Person
{
public:
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
Person(const Person& p) = delete;
private:
string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = move(s1);
return 0;
}
这样吴凯伦是内部和外部都无法使用这个拷贝构造函数了。
可变参数模板
参数包
这个也是为了对标C语言的可变性参数，比如printf和scanf。
#include<iostream>
using namespace std;
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
int main()
{
return 0;
}
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数
包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，
只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特
点，也是最大的难点，即如何展开可变模版参数。
如何查看参数包有几个参数呢？
#include<iostream>
using namespace std;
template <class ...Args>
void ShowList(Args... args)
{
cout << sizeof...(args) << endl;//查看参数包有几个参数
}
int main()
{
ShowList(1);
ShowList(1, 2.2);
ShowList(1, 2.2, string("xxx"));
return 0;
}
遍历参数包中的参数
递归函数方式展开参数包
#include<iostream>
using namespace std;
// 递归终止函数
void ShowList()//当参数包中的参数变成0个的时候就会调用这个函数
{
cout << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)//第一个参数传给value，剩下的参数传给args参数包
{
cout << value << " ";
ShowList(args...);
}
int main()
{
ShowList(1);//这里1传给value，然后参数包没有参数调用终止函数
ShowList(1, 2.2);//这里第一次1传给value，2.2传给参数包，第二次2.2传给value，参数包没有值，调用终止函数
ShowList(1, 2.2, string("xxx"));
return 0;
}
非常的怪异。
逗号表达式展开参数包
#include<iostream>
using namespace std;
template <class T>
void PrintArg(T t)
{
cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (PrintArg(args), 0)... };
cout << endl;
}
int main()
{
ShowList(1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}
这里的arr数组是一个辅助的作用，里面调用的是PrintArg函数，编译器自行初始化arr数组，参数包中有多少个参数数组的空间就有多大。
这里的逗号表达式只是为了初始化arr数组，初始化为0。
STL容器中的empalce相关接口函数
http://www.cplusplus.com/reference/vector/vector/emplace_back/
emplace_back是可以不传参的，那么默认用户的就是匿名构造，传入的值就是0。
那么emplace_back的意义在哪里呢？
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<pair<int, string>>arr;
arr.emplace_back(1, "xxx");//这里可以这样初始化(直接构造),push_back只能构造一个对象去传，当然emplace_back也可以构造一个对象传
return 0;
}
其实就是一种优化，如果传入的是右值编译器可以直接优化成直接构造（移动构造或者是移动赋值都省下了），不需要任何拷贝构造或者是移动构造（如果是左值还是构造+深拷贝）。
lambda表达式
为什么要有lambda表达式
这个和仿函数有些类似。
举个例子，如果定义水果类，创建多个水果对象，那么他们分别有名字，价格，评价等等属性，如果想通过sort函数来实现对于不同对象的排序就要写很多个仿函数，非常的麻烦。
#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std;
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());
return 0;
}
那么这个时候lambda表达式就可以上场了。
#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std;
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(), [](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; });//按照评价排序
return 0;
}
这是按照价格排序的结果：
这是按照评价排序：
lambda表达式的格式
lambda表达式书写格式：[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函数不能做任何事情。
#include<iostream>
using namespace std;
int main()
{
//其实lambda就是要给可调用的对象
auto compare = [](int x, int y) {return x > y; };//这个类型编译器认识，但是我们不认识
cout << compare(1, 2) << endl;
return 0;
}
那么，在外部定义的变量能在lambda表达式中使用吗？
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
auto add1 = []() { return a + b; };
return 0;
}
这里是不可以的，因为是两个不同的作用域，这个时候需要捕捉这两个变量才可以使用。
auto add1 = [a, b]() { return a + b; };
这个时候编译就通过了。
那么如果想交换两个变量呢？
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
auto swap1 = [a, b]()
{
int c = a;
a = b;
b = c;
};
return 0;
}
这里是不允许的，如果想修改要加mutable。
auto swap1 = [a, b]()mutable
{
int c = a;
a = b;
b = c;
};
但是外部的a和b并没有发生改变，也就是说捕捉的对象是传值拷贝，加了一个const的变量，mutable只是让他们变成非const属性的值。
如果想改变就要这样：
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
auto swap1 = [&a, &b]()//这里虽然是外部a和b的别名，但是不能修改a和b的名字，不然就不能捕捉了
{
int c = a;
a = b;
b = c;
};
return 0;
}
这里也无法在捕捉列表取地址。
在捕捉列表里面可以用=就是捕捉父作用域向上的变量，&是捕捉父作用域向上的变量别名。（向上就是在捕捉列表语句前面的所有变量）
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
auto add1 = [=]() { return a + b; };
auto swap1 = [&]()
{
int c = a;
a = b;
b = c;
};
return 0;
}
注意：这些可以进行混合捕捉，比如对父作用域向上的变量进行传值捕捉，对于某一个或者是某些进行引用捕捉。
lambda的底层
#include<iostream>
using namespace std;
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表达式的反汇编，也就是说本质都是一样的调用仿函数。
并且lambda表达式的类型名字也很繁琐。
包装器
function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
#include<iostream>
using namespace std;
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;
}
这里实例化的三分不同的函数，有没有什么办法让他不生成这么多的函数。
#include<iostream>
#include<functional>
using namespace std;
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
int main()
{
function<int(int, int)> f1;//第一个int是返回值，括号里面的是参数
f1 = f;//封装到f1中
cout << f1(1, 2) << endl;
function<int(int, int)> f2(f);//这种方法也可以将f封装到f2中
cout << f2(1, 2) << endl;
function<int(int, int)> f3 = Functor();
cout << f3(1, 2) << endl;
/*function<int(int, int)> f4(Functor());//这里不可以，因为编译器会识别成为函数指针
cout << f4(1, 2) << endl;*/
function<int(int, int)> f5 = [](const int a, const int b){return a + b; };
cout << f5(1, 2) << endl;
}
类中的成员函数也是可以包装的，但是要注意：
#include<iostream>
#include<functional>
using namespace std;
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
int plusd(int a, int b)
{
return a + b;
}
};
int main()
{
//这里存入的是函数指针
function<int(int, int)> f1 = &Plus::plusi;//静态成员函数可以不加&
cout << f1(1, 2) << endl;
function<int(Plus, int, int)> f2 = &Plus::plusd;//非静态成员函数必须加&，这里还要加一个参数，因为传参还有一个this指针
cout << f2(Plus(), 1, 2) << endl;//这里是传进去一个Plus类型的对象，其实就是利用这个对象调用该成员函数而已
}
其实包装器就是对于可调用对象类型的大统一。
那么使用的场景呢？
力扣：逆波兰表达式
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
map<string, function<int(int, int)>> opMap=
{
{"+",[](int x, int y){return x+y;}},
{"-",[](int x, int y){return x-y;}},
{"/",[](int x, int y){return x/y;}},
{"*",[](int x, int y){return x*y;}}
};//这里就是统一了类型
for(auto& e:tokens)//在map中查找符号
{
if(opMap.count(e))
{
int a = st.top();
st.pop();
int b = st.top();
st.pop();
st.push(opMap[e](b, a));//找到之后就将栈中的两个值通过map中储存的包装器中的lamber表达式进行运算，这里要注意数的顺序，先去取出来的在左边，后取出来的在右边
}
else
{
st.push(stoi(e));
}
}
return st.top();
}
};
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);
举例：
#include<iostream>
#include <functional>
using namespace std;
int Plus(int a, int b)
{
return a - b;
}
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
function<int(int, int)> func1 = bind(Plus, placeholders::_1,placeholders::_2);//placeholders是占位对象
cout << func1(1, 2) << endl;
//_1代表本来的第一个参数，_2代表本来的第二个参数
//这里调参数
function<int(int, int)> func3 = bind(Plus, placeholders::_2, placeholders::_1);
cout << func3(1, 2) << endl;
return 0;
}
那么实际的作用在哪里呢？
比如包装器包装的是类的成员函数，传参的时候第一个总是类的匿名对象，写起来很麻烦。
#include<iostream>
#include <functional>
using namespace std;
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
int main()
{
function<int(int, int)> func1 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
cout << func1(1, 2) << endl;//这里本来是三个参数，但是第一个参数已经被绑定了，包装器的参数也不用写三个了，这里也不用传三个参数了
return 0;
}
