C++11
本篇将介绍C++11增加的语法种较为实用的部分
统一的列表初始化
｛｝初始化
c++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定：
struct A
{
int _a;
int _b;
};
int main()
{
int a[] = { 1,2,3,4 };
A a = { 4,6 };
return 0;
} C++11 扩大了用大括号括起的列表 ( 初始化列表 ) 的使用范围，使其可用于所有的内置类型和用户自
定义的类型,使用初始化列表时，可添加等号 (=) ，也可不添加
一切都可以用列表初始化
struct A
{
int _a;
int _b;
};
int main()
{
int i = 0;
int j = { 0 };//可以这样初始化
int k{ 0 };//也可以这样初始化
int a[]{ 1,2,3,4 };
A a { 4,6 };
return 0;
}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(2024, 1, 28);
//本质是类型转换 构造+拷贝构造->优化为直接构造
//构造+拷贝构造：用{ 2024,1,28 }构造出来一个Date类的临时对象，再用这个临时对象拷贝构造生成d2
Date d2 = { 2024,1,28 };
Date d3{ 2024,1,28 };
//Date &d4 = { 2024,1,28 };代码报错-->临时对象具有常属性
const Date& d4 = { 2024,1,28 };//ok
Date* p1 = new Date[3]{ d1,d2,d3 };
Date* p2 = new Date[3]{ {2024,1,26},{2024,1,27},{2024,1,28} };
return 0;
}std::initializer_list
std::initializer_list的类型：
int main()
{
// the type of il is an initializer_list
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
return 0;
}
std::initializer_list使用场景：
std::initializer_list 一般作构造函数的参数， C++11 对 STL 中的不少容器就增加 std::initializer_list作为参数的构造函数，这样初始化容器对象就很方便。也可以作为 operator= 的参数，这样就可以用大括号赋值
int main()
{
vector v1 = { 1,2,3,4 };//任意个数
vector v2 = { 1,2,3,4,5,6};
v1 = { 10,20,30 };
list lt = { 10,20,30 };
return 0;
} 注意区分：
//本质是多参数构造类型转换 构造+拷贝构造->优化成直接构造
// 跟对应构造函数参数个数匹配
Date d2 = { 2023, 11, 25 };//不是initializer_list ,因为{不是任意个数}
//Date d3 = { 2023, 11, 25，99};//报错
vector v = { 1,2,3,4,5 };//是initializer_list，{任意个数} int main()
{
initializer_list il2 = { 10, 20, 30};
initializer_list::iterator it2 = il2.begin();
while (it2 != il2.end())
{
cout << *it2 << " ";
++it2;
}
cout << endl;
return 0;
} 
int main()
{
pair kv1("sort", "排序");
// 这里{"pear", "梨"}会先初始化构造一个pair对象
map dict = {{"pear", "梨"}, {"apple","苹果"} };
for (auto& kv : dict)
{
cout << kv.first << ":" << kv.second << endl;
}
return 0;
} 
auto
在C++11中，auto用于实现 类型的自动推导， 这样要求必须进行 显示初始化
对于简单的类型如int，double等，auto实现的自动推导类型用处不大，但是对于复杂且长的类型，如进行迭代器遍历时，auto的用处就大了
int main()
{
int i = 0;
auto j = i;
cout << typeid(i).name() << endl;
return 0;
}
int main()
{
vector v = { 1,2,3,4 };
//vector::iterator it = v.begin();
auto it = v.begin();//简化
while (it != v.end())
{
cout << *it << " ";
it++;
}
cout << endl;
return 0;
} decltype
获取类型有typeid(i).name()，但是经由此种方法所获取到的类型无法用于定义变量
decltype的出现则解决了这种困境
decltype可以推导对象的类型， 这个类型是可以用来模板实参，或者再定义对象
int main()
{
int i = 1;
double d = 2.2;
// 类型以字符串形式获取到
cout << typeid(i).name() << endl;//可以打印
cout << typeid(d).name() << endl;
// typeid(i).name() j;//不可以 编译器报错 typeid(i).name()获取到的类型来定义变量
auto ret = i * d;
decltype(ret) x;//可以用来定义变量
cout << typeid(ret).name() << endl;
vector v;
v.push_back(1);
v.push_back(1.1);
for (auto e : v)
{
cout << e << " ";
}
return 0;
} 
// decltype的一些使用使用场景
template
void F(T1 t1, T2 t2)
{
decltype(t1 * t2) ret;
cout << typeid(ret).name() << endl;
}
int main()
{
int x = 1;
double y = 2.2;
decltype(x * y) ret;//ret的类型是double
decltype(&x) m;//m的类型是int*
cout << typeid(ret).name() << endl;
cout << typeid(m).name() << endl;
F(1, 'k');
return 0;
} nullptr
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif C++ 中 NULL 被定义成字面量0，但是由于 0 既能指针常量，又能表示整形常量，故而在某些情况下会导致问题的出现，出于清晰和安全的角度考虑，C++11 中新增了 nullptr ，用于表示空指针
右值引用和移动语义
左值引用和右值引用
无论左值引用还是右值引用，都是给对象 取别名
左值引用符号：& 右值引用符号：&&
左值和右值的本质区分： 左值可以取地址，右值不可以取地址
左值是一个表示数据的表达式 ( 如变量名或解引用的指针 ) ， 我们可以获取它的地址 + 可以对它赋
值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边 。定义时 const 修饰符后的左
值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名
int main()
{
// 以下的p、b、c、*p都是左值(都能取地址）
//p中存储一个整型变量的地址，如int*p = &a *p即为a
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pa = *p;
return 0;
} 右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值 ( 这个不能是左值引
用返回 ) 等等， 右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能
取地址 。右值引用就是对右值的引用，给右值取别名
int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是右值
6;//字面常量
x + y;//表达式返回值
fmin(x, y);//函数返回值
// 以下几个都是对右值的右值引用
int&& rr1 = 6;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}
左值引用与右值引用比较
关于左值引用：
1. 左值引用只能引用左值，不能引用右值。即左值引用不能给右值取别名
2. 但是 const 左值引用既可引用左值，也可引用右值
int a = 9;
int& ra = a;//ra为a的别名
//int& rb = 10;//报错 因为10为右值，具有常属性，不可被修改，左值引用后，就可通过对rb的修改从而修改10，导致权限放大，不被允许
const int& rb = 10;//const修饰后，不能通过对rb的修改而修改10，权限的平移是可以的
int i = 0;
int j = 8;
const int& rk = i + j;//ok const左值引用--引用右值
const int& rl = a;//const左值引用--引用左值 权限的缩小是可以的
return 0;关于右值引用：
1. 右值引用只能右值，不能引用左值。即右值引用不能给左值取别名
2. 但是右值引用可以引用 move 以后的左值。
int&& ra = 10;//右值引用--引用右值/给右值取别名
int b = 9;
//int&& rb = b;//不可以
int&& rb = move(b);//右值引用--引用move后的左值/给move(左值)取别名右值引用使用场景和意义
左值引用既可以引用左值和又可以引用右值，为什么C++11还要提出右值引用？这是因为左值引用存在短板，右值引用的提出是为了解决左值引用无法解决的问题
左值引用的使用场景：
引用传参和引用返回的正确使用都能减少拷贝，提高效率
1 引用传参（任何场景都适用）
void func(const T&x)
2 引用返回（部分场景适用--出了函数作用域，返回对象的生命周期还没有结束）
T&func()
左值引用的短板：
当函数返回对象是一个局部对象（出了函数作用域生命周期结束）则不能使用左值引用返回，否则会出问题，只能传值返回，但是传值返回就需要拷贝，特别是某些情况下需要深拷贝的时候，代价比较大
此时右值引用将会发挥作用，在演示之前，我们需要知道：
右值分类：
1 纯右值 内置类型右值
2 将亡值 自定义类型右值
右值引用的出现，可以让我们设计出移动构造与移动赋值 （与将亡值有关）
以下代码截取于本人自己实现string的相关代码
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)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp);
}
//移动构造
string (string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
swap(s);
}
// 赋值重载
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
swap(tmp);
}
return *this;
}
//移动赋值
string& operator=(string&& s)
{
swap(s);
return *this;
}
移动构造与移动赋值合理利用编译器特殊处理，识别成的将亡值，转移将亡值资源为己所用。
移动构造本质是将参数右值的资源窃取过来，占为已有，那么就不用做深拷贝了，所以它叫做移动构造，即窃取别人的资源来构造自己，移动构造中没有新开空间，拷贝数据，所以效率提高了
djx::string s1("hello world");
move(s1);//表达式为右值 但是s1仍为左值
djx::string s3 = s1;//s1拷贝构造s3
djx::string s4 = move(s1);//移动构造 但是要注意，一般是不要这样用的，因为s1的资源被转移给了s4，s1被置空了
// 拷贝构造
//string(const string & s)
//移动构造
//string(string && s)
//const左值引用与右值引用皆能引用右值，但是会走更匹配的右值引用 当需要用右值引用引用一个左值时，可以通过 move 函数将左值强制“转化”为右值
但是需要注意的是：
move(左值）：整个表达式的结果是右值，但是左值还是左值没有因此变成右值
STL 中的容器在C++11以后都增加了移动构造和移动赋值
STL容器插入接口函数也增加了右值引用版本
右值被右值引用后的属性是左值
forward是完美转发
完美转发
模板中的&& 万能引用
模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值
若是我们希望在传递过程中保持它原来的属性（左值或者右值的属性），就需要使用完美转发
forward 完美转发在传参的过程中保留对象原生类型属性
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
void PerfectForward(T&& t)
{
Fun(t);
}
int main()
{
PerfectForward(4); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(move(a)); // 右值
const int b = 6;
PerfectForward(b); // const 左值
PerfectForward(move(b)); // const 右值
return 0;
} 
为什么结果都是左值引用？右值引用呢？
因为左值引用后的属性还是左值 右值引用后属性退化成了左值
期望保持原生属性，则需要forward完美转发
template
void PerfectForward(T&& t)
{
Fun(forward(t));
} 
完美转发实际中的使用场景：
以模拟实现list为例：
使用右值引用的地方，若要传递参数右值，则需要使用完美转发来保持该参数的原生属性
否则该参数被右值引用后，属性退化成左值，不能正确调用函数
新的类功能
默认成员函数
原来 C++ 类中，有 6 个默认成员函数：
1. 构造函数
2. 析构函数
3. 拷贝构造
4. 赋值重载
5. 取地址重载
6. const 取地址重载
重要的是前 4 个，后两个不用太关注
默认成员函数即：我们不写，编译器会默认生成一个
C++11 新增了两个：移动构造和移动赋值
注意细则：
1 如果我们没有实现移动构造，且 析构函数 、拷贝构造，赋值重载都没有实现 ，那么编译器会自动生成一个默认的移动构造
默认生成的移动构造函数，对于内置类型的成员完成浅拷贝，对于自定义类型的成员，如果该成员实现了移动构造，则调用该成员的移动构造，如果没有实现，则调用该成员的拷贝构造
2 如果我们没有实现移动赋值，且 析构函数 、拷贝构造，赋值重载都没有实现 ，那么编译器会自动生成一个默认的移动赋值
默认生成的移动赋值函数，对于内置类型的成员完成浅拷贝，对于自定义类型的成员，如果该成员实现了移动赋值，则调用该成员的移动赋值，如果没有实现，则调用该成员的赋值重载
3 如果我们自己实现了移动构造与移动赋值，那么编译器将不会自动生成
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& operator=(const Person& p)
{
if(this != &p)
{
_name = p._name;
_age = p._age;
}
return *this;
}*/
/*~Person()
{
cout << "~Person()" << endl;
}*/
private:
djx::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;//拷贝构造
Person s3 = move(s1);//移动构造
Person s4;
s4 = move(s2);//移动赋值
return 0;
}default
功能：强制生成默认函数
如若我们要使用某个默认生成的函数，但是因为一些原因，这个函数没有默认生成，比如：
我们实现了拷贝构造，那么就不会生成默认的移动构造，那么我们可以使用default关键字显示指定移动构造生成
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;//移动构造
Person& operator=(Person&& p) = default;//移动赋值
private:
djx::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1; //拷贝构造
Person s3 = move(s1); //移动构造
Person s4;
s4 = move(s2);//移动赋值
return 0;
}delete
功能：禁止生成默认函数
想要 限制某些默认函数的生成 ，只需在该函数声明加上=delete，称 =delete 修饰的函数为删除函数
// 不让生成实现
//Person(Person&& p) = delete; 
可变参数模板
C++98/03中，类模版和函数模版中只能含固定数量的模版参数，C++11中新增的可变参数模板是一个巨大的进步，但是使用起来比较晦涩，需要耐心与细心
可变参数的函数模板例子：
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template
void ShowList(Args... args)
{} 参数 args 前面有省略号，它是一个可变模版参数
带省略号的参数称为 “ 参数包” ，它里面包含了 0 到 N （ N>=0 ）个模版参数
我们无法直接获取参数包args中的每个参数，只能通过展开参数包的方式来获取参数包中的每个参数，注意： 语法不支持使用 args[i] 这样方式获取可变 参数
template
void ShowList(Args... args)
{
cout << sizeof...(args) << endl;
// 不支持以下做法
for (size_t i = 0; i < sizeof...(args); i++)
{
cout << args[i] << " ";
}
cout << endl;
}
展开参数包：
递归函数方式展开参数包
void _ShowList()// 递归终止函数
{
cout << endl;
}
template
void _ShowList(const T&val,Args...args)// 展开函数
{
cout << val << " ";
_ShowList(args...);
}
template
void ShowList(Args...args)
{
_ShowList(args...);
}
int main()
{
ShowList(1);
ShowList(1, 2);
ShowList(1, 2, 3);
ShowList(1, 2.2, 'r');
} 
展开参数包的第二种方式
template
int PrintArg(T&& t)
{
cout << t << " ";
return 0;
}
//展开函数
template
void ShowList(Args&&...args)
{
// 要初始化arr，就必须强行解析参数包，参数包有几个参数，PrintArg就依次推演生成几个
int arr[] = { PrintArg(args)... };
cout << endl;
}
int main()
{
ShowList(9);
ShowList(9, 'A');
ShowList(9, 'A', std::string("apple"));
return 0;
} STL容器中的empalce相关接口函数
template
void emplace_back (Args&&... args); 
emplace系列的接口，支持模板的可变参数，且为万能引用
相较于push_back，insert等 ，emplace系列的接口的优点在哪里呢？
lambda表达式
引言：排序是很频繁常见的，对于内置类型的排序，使用库函数中的sort，轻而易举
但对于自定义类型元素的排序，往往需要我们自己设计比较规则，方式是写仿函数，即设计一个类，重载()，但这种写法极其不便，如果每次比较的逻辑不一样，还要实现多个类，因此，在C++11语法中出现了Lambda表达式
设计仿函数比较对象
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 v = { { "葡萄", 4.4, 5 }, { "草莓", 4, 4 }, { "橙子", 2.2, 3 }, { "甜瓜", 3.3, 4 } };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
return 0;
} 使用lambda表达式
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
//...
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
int main()
{
vector v = { { "葡萄", 4.4, 5 }, { "草莓", 4, 4 }, { "橙子", 2.2, 3 }, { "甜瓜", 3.3, 4 } };
//sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {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._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; });
return 0;
} lambda 表达式实际是一个匿名函数对象
lambda表达式语法
lambda 表达式书写格式： [capture-list] (parameters) mutable -> return-type { statement }
[capture-list] : 捕捉列表 ，该列表总是出现在 lambda 函数的开始位置， 编译器根据 [] 来
判断接下来的代码是否为 lambda 函数 ， 捕捉列表能够 捕捉父作用域中的变量 供 lambda 函数使用
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用
父作用域指包含lambda函数的语句块
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针
class AA
{
public:
void func()
{
auto f1 = [=] {//会捕捉this指针
cout << a1 << endl;
cout << a2 << endl;
};
f1();
}
private:
int a1 = 1;
int a2 = 1;
};
int main()
{
AA().func();
return 0;
}
捕捉列表的注意细则：
1 语法上捕捉列表可由多个捕捉项组成，并以逗号分割 。
比如： [=, &a, &b] ：以引用传递的方式捕捉变量 a 和 b ，值传递方式捕捉其他所有变量
[& ， a, this] ：值传递方式捕捉变量 a 和 this ，引用方式捕捉其他变量
int main()
{
int x = 0, y = 1, z = 2;
auto f1 = [=, &z]{
z++;
cout << x << endl;
cout << y << endl;
cout << z << endl;
};
f1();
return 0;
}
2 捕捉列表不允许变量重复传递，否则就会导致编译错误 。
比如： [=, a] ： = 已经以值传递方式捕捉了所有变量，捕捉 a 重复
3 在块作用域以外的 lambda 函数捕捉列表必须为空
4 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者 非局部变量都 会导致编译报错
5 lambda 表达式之间不能相互赋值 ，即使看起来类型相同
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
// lambda表达式是一个匿名函数对象，可用typeid查看其类型
//
auto f1 = [](int x)->int {cout << x << endl; return 0; };
f1(1);
// class
cout << typeid(f1).name() << endl;
auto f2 = [](int x)
{
cout << x << endl;
return 0;
};
f2(2);
//f1 = f2;//No 编译报错 二者类型不同
//class
cout << typeid(f2).name() << endl;
ComparePriceGreater f3;
//struct ComparePriceGreater
cout << typeid(f3).name() << endl;
return 0;
}
(parameters)：参数列表 。与 普通函数的参数列表一致 ，如果不需要参数传递，则可以连同() 一起省略
mutable ：默认情况下， lambda 函数总是一个 const 函数， mutable 可以取消其常量性。 使用该修饰符时，参数列表不可省略(即使参数为空)。
可以这样看：lambda表达式本身是一个匿名函数对象（与仿函数类似）lambda表达式的类型是类，lambda捕捉列表捕捉的变量会作为该类的成员变量，但是会被const修饰，无法更改，加上mutable就相当于去掉了const，可以正常使用捕捉回来的成员变量
->returntype：返回值类型 。用 追踪返回类型形式声明函数的返回值类型 ，没有返回
值时此部分可省略。 返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导 。
{statement}：函数体 。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
在 lambda 函数定义中， 参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为 空 。因此 C++11 中 最简单的 lambda 函数为： []{} ; 该 lambda 函数不能做任何事情。
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[] {};
// 省略参数列表和返回值类型，返回值类型由编译器推导为int
int a = 3, b = 4;
[=] {return a + b; };
// 省略了返回值类型，无返回值类型
auto fun1 = [&](int c) {b = a + c; };
fun1(9);
cout << a << " " << b << endl;
// 各部分都很完善的lambda函数
auto fun2 = [=, &b](int c)->int {return b += a + c; };
cout << fun2(9) << endl;
int x = 10;
auto fun3 = [x](int a) mutable { x *= 2; return a + x; };
cout << fun3(10) << endl;
return 0;
}
void (*PF)();
int main()
{
auto f1 = [] {cout << "hello world" << endl; };
// 允许使用一个lambda表达式拷贝构造一个新的副本
auto f2(f1);
f2();
// 可以将lambda表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}
使用lambda表达式交换两数的值
1.
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
auto f1 = [](int& r1, int& r2) {
int tmp = r1;
r1 = r2;
r2 = tmp;
};
f1(x, y);
cout << x << " " << y << endl << endl;
return0;
}
错误使用：
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
auto f2 = [x, y]() mutable //值传递方式捕捉变量，相当于捕捉回来的是克隆体，不是本体，对克隆体的交换，影响不了本体
{
int tmp = x;
x = y;
y = tmp;
};
f2();
cout << x << " " << y << endl << endl;
return 0;
} 
2.
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
auto f3 = [&x, &y]
{
int tmp = x;
x = y;
y = tmp;
};
f3();
cout << x << " " << y << endl << endl;
return 0;
} 
函数对象与lambda表达式
函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了 operator() 运算符的类对象
从使用方式上来看，函数对象与 lambda 表达式完全一样
class A
{
public:
A(double a)
: _a(a)
{}
double operator()(double b)
{
return _a * b;
}
private:
double _a;
};
int main()
{
// 函数对象
double a = 8.8;
A aa(a);
cout << aa(2.2) << endl;;
// lamber表达式
auto r = [=](double b)->double {return a * b; };
cout<
转汇编看底层：
实际在底层编译器对于 lambda 表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个 lambda 表达式，编译器会自动生成一个类，在该类中重载了 operator() 。
包装器
function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器
std::function在头文件
// 类模板原型如下
template function; // undefined
template
class function;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参 可调用对象有：
1 函数指针 缺点--用起来比较奇怪，如 void(*pswap)(int*p1,int*p2)
2 仿函数 缺点--"笨重"
3 lambda 缺点--匿名
#include
void swap_func(int& r1, int& r2)
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
struct Swap
{
void operator()(int& r1, int& r2)
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
};
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
auto swaplambda = [](int& r1, int& r2) {
int tmp = r1;
r1 = r2;
r2 = tmp;
};
function f1 = swap_func;//函数指针
f1(x, y);
cout << x << " " << y << endl << endl;
function f2 = Swap();//仿函数
f2(x, y);
cout << x << " " << y << endl << endl;
function f3 = swaplambda;//lambda表达式
f3(x, y);
cout << x << " " << y << endl << endl;
map> cmdOP = {
{"函数指针", swap_func},
{"仿函数", Swap()},
{"lambda", swaplambda},
};
cmdOP["函数指针"](x, y);
cout << x << " " << y << endl << endl;
cmdOP["仿函数"](x, y);
cout << x << " " << y << endl << endl;
cmdOP["lambda"](x, y);
cout << x << " " << y << endl << endl;
return 0;
} bind
std::bind 函数定义在头文件中， 是一个函数模板，它就像一个函数包装器 ( 适配器 ) ， 接受一个可
调用对象（ callable object ），生成一个新的可调用对象来 “ 适应 ” 原对象的参数列表 。一般而
言，我们用它可以把一个原本接收 N 个参数的函数 fn ，通过绑定一些参数，返回一个接收 M 个（ M
可以大于 N ，但这么做没什么意义）参数的新函数。同时，使用 std::bind 函数还可以实现参数顺
序调整等操作。
可以将 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 为第二个参数，以此类推
// 原型如下：
template
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template
/* unspecified */ bind (Fn&& fn, Args&&... args); #include
int Plus(int a, int b)
{
return a + b;
}
int main()
{
//绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
function f1 = bind(Plus, placeholders::_1, placeholders::_2);
//auto f1 = bind(Plus, placeholders::_1, placeholders::_2);
//function f1 =Plus
cout << f1(1, 2) << endl;
//指定参数
auto f2 = bind(Plus, 3, 4);
cout << f2(1, 2) << endl;
cout << f2() << endl;
return 0;
}
//结果 3 7 7 #include
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
// 成员函数取地址，比较特殊，要加一个类域和&
function f1 = &Plus::plusi;//static修饰的成员函数，取地址可以不加&，但是也可以加上
cout << f1(1, 2) << endl;
function f2 = &Plus::plusd;
Plus ps;
cout << f2(&ps, 1.1, 2.2) << endl;
function f3 = &Plus::plusd;
cout << f3(Plus(), 3.3, 4.4) << endl;
function f4 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);
cout << f4(4.4,5.5) << endl;//使用bind简化传参的数量
return 0;
} 
调整参数顺序/个数：
#include
int Sub(int a, int b)
{
return a - b;
}
int main()
{
function f1 = Sub;
cout << f1(9, 2) << endl;
// 调整参数顺序
function f2 = bind(Sub, placeholders::_2, placeholders::_1);
cout << f2(9, 2) << endl;
// 调整参数个数，有些参数可以bind时写死
function f3 = bind(Sub, 20, placeholders::_1);
cout << f3(2) << endl;
return 0;
} 