【ONE·C++ || C++11（一）】
总言
主要介绍C++11中的一些功能语法。
文章目录
- 总言
- 0、思维导图
- 1、基本情况简介
- 2、统一的列表初始化
-
- 2.1、{}的使用
- 2.2、initializer_list
-
- 2.2.1、基础介绍
- 2.2.2、在各容器中实现说明
- 3、声明
-
- 3.1、auto
- 3.2、nullptr
- 3.3、decltype
- 4、范围for
- 5、智能指针
- 6、STL中一些变化
-
- 6.1、C++11中新增容器
- 6.2、容器中的一些新方法
- 7、右值引用和移动语义
-
- 7.1、左值引用和右值引用基本介绍
- 7.2、左值引用与右值引用使用比较
- 7.3、相关应用
-
- 7.3.1、问题引入
- 7.3.2、解决方案一：输出型参数
- 7.3.3、解决方案二：右值引用（介绍移动构造和移动赋值）
- 7.3.4、一些说明
- 7.4、完美转发
-
- 7.4.1、介绍模板中的&&：万能引用/引用折叠
- 7.4.2、介绍完美转发
- 8、新的类功能
-
- 8.1、新增默认成员函数：两个
- 8.2、关键字
-
- 8.2.1、default和delete、如何创建一个只在堆区的
- 8.2.2、final和override
- 9、可变参数模板
-
- 9.1、基础概念介绍
- 9.2、STL容器中的emplace相关接口函数
- 10、lambda表达式
-
- 10.1、问题引入
- 10.2、lambda表达式基本介绍
-
- 10.2.1、基本语法
- 10.2.2、使用举例（基本使用、捕捉列表介绍）
- 10.2.3、示例演示
- 10.2.4、相关底层
- 11、包装器
-
- 11.1、function
-
- 11.1.1、问题引入：为什么
- 11.1.2、基本格式：是什么
- 11.1.3、问题解决：有什么用
- 11.2、bind
-
- 11.2.1、基本说明
- 11.2.2、使用演示
- 12、多线程
0、思维导图
1、基本情况简介
情况说明：C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。
2、统一的列表初始化
2.1、{}的使用
1）、对{}的使用改进说明
在C++98中，能够使用到花括号{}的地方有：对数组或结构体元素进行统一的列表初始值设定。
struct Student
{
int _ID;
int _score;
};
void test01()
{
//对数组初始化时使用花括号
int arr[] = { 1,2,3,4,5 };
int arr2[5] = { 0 };
//对结构体初始化时使用花括号
struct Student s1 = { 212121,92 };
}
C++11扩大了用花括号括起的列表(即初始化列表)的使用范围。①使其可用于所有的内置类型和自定义类型，②创建对象时也可以使用列表初始化方式调用构造函数初始化。
2）、相关演示一
使用列表初始化内置类型和自定义类型
对内置类型和自定义类型：使用初始化列表{}初始化，可加等号，也可不加。
struct Student
{
int _ID;
int _score;
};
void test02()
{
//常规写法：
int x1 = 1;
//C++11给出的初始化列表{}写法，使用初始化列表时，=可以省略
int x2 = { 2 };
int x3{ 3 };
//常规写法：
int arr1[] = { 1,2,3,4,5 };
//C++11给出的初始化列表{}写法:
int arr2[]{ 1,2,3,4,5 };
int arr3[5]{ 0 };
struct Student s1{202020,99};
}
演示如下：下述d1、d2、d3都是在创建类对象时，调用其构造函数进行初始化。
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;
};
void test03()
{
Date d1(2023, 6, 1);
Date d2 = { 2023,7,15 };
Date d3{ 2023,8,24 };
}
3）、相关演示二
step1：
问题：按道理，我们使用()即可解决很多初始化问题，那么 这种初始化方式有何意义价值？ ==
回答：主要体现在对各类容器的使用中。
在C++98，当我们使用各类容器进行构造对象时，能初始化的方式如上述（这里只举例了vector、list，其它容器接口可参考相关网址查询）。
//分别在两容器中存储1，2，3，4，5
int arr[] = { 1,2,3,4,5 };
//以下为一种对象初始化方式
vector<int> v1;
for (auto e : arr)
{
v1.push_back(e);
}
list<int> lt1;
for (auto e : arr)
{
lt1.push_back(e);
}
C++11中，由于{}可使用于类对象，因此我们有了以下的初始化方式：(事实上在之前的博文中，我们也曾使用过，只是当时没有对其详细讲解)
vector<int>v2 = { 1,2,3,4,5,6 };
vector<int>v3{ 1,2,3,4,5,6 };
list<int> lt2 = { 1,2,3,4,5,6 };
list<int> lt3{ 1,2,3,4,5,6 };
step2
问题：这种初始化方式是如何支持的呢？
auto x = { 1,2,3,4,5,6 };
cout << typeid(x).name() << endl;
回答：如上述，我们使用typeid().name()来确认其类型，发现其给出的是initializer_list
2.2、initializer_list
2.2.1、基础介绍
相关链接：initializer_list
可以看到它的相关接口很少，但实现了类似于begin、end的迭代器接口。
其它容器的构造函数都支持这样一个接口，所以我们可以使用初始化列表进行初始化。（以下只是举例vector、list，其它容器可查询相关文档）
2.2.2、在各容器中实现说明
1）、相关演示一：对自己模拟实现的vector、list演示
基于上述，对于自己写的vector等容器，若要支持上述初始化列表方式创建对象，也需要提供相应的构造构造。此处以vector为例：
//initializer_list构造：C++11
vector(initializer_list<T> il)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(il.size());
for (auto& e : il)
{
push_back(e);
}
}
2）、相关演示二：vector< Date> 类型嵌套、map
演示代码如下：
void test03()
{
Date d1(2023, 6, 1);
Date d2 = { 2023,7,15 };
Date d3{ 2023,8,24 };
vector<Date> v1 = { d1,d2,d3 };
vector<Date> v2 = { {2023,10,01},{2022,4,29},{2022,6,19} };
//构造
map<string, string> m1 = { {"决明子","明目"},{"薄荷","辛凉"},{"鱼腥草","消炎"} };
//赋值重载
initializer_list<pair<const string, string>> kvil = { {"决明子","明目"},{"薄荷","辛凉"},{"鱼腥草","消炎"} };
map<string, string> m2;
m2 = kvil;
}
演示结果如下：
3、声明
auto和nullptr在C++基础中有做介绍，故此处不多谈论。
3.1、auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。
3.2、nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
3.3、decltype
1）、基础介绍
说明： 关键字decltype将变量的类型声明为表达式指定的类型。
演示代码如下：
void test06()
{
const int x = 2;
double y = 2.2;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p; // p的类型是int*
cout << typeid(ret).name() << endl;
cout << typeid(p).name() << endl;
}
有什么用处呢？
比如下述这个场景中，我们需要定义一个变量ret用域记录T1，T2的乘积，但T1，T2为模板参数，其类型是不明确的，此处就可以使用template来解决。
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
decltype(t1 * t2) ret;
cout << typeid(ret).name() << endl;
}
2）、与typeid.name()的区别演示
typeid只能获取类型，用于查看，decltype获取类型后可建立相应类型的变量。
int val = 8;
decltype(val) ret2 = 22;//right
typeid(val).name() ret3 = 22;//error
3）、与auto的区别演示
auto是根据给定数值推到其类型，decltype直接将变量的类型定义为指定类型，因此存在类型转换。
int val = 8;
decltype(val) ret4 = 22.22;//浮点值，会发生隐式类型转换
auto ret5 = 22.22;
cout << ret4<< " " << typeid(ret4).name() << endl;
cout << ret5 << " " << typeid(ret5).name() << endl;
4、范围for
同Ｃ++基础章有提及。
5、智能指针
暂补。
6、STL中一些变化
6.1、C++11中新增容器
1）、C++11中新增容器说明
哪些属于新增容器：unordered系列、forward_list单链表、array。
6.2、容器中的一些新方法
1）、C++11中新增容器说明
容器中都增加了一些C++11的方法。例如：
1、都支持initializer_list构造，用来支持列表初始化
2、新提供了一些接口，如cbegin和cend，用于返回const迭代器等等
3、移动构造和移动赋值：相关内容后续讲解
4、右值引用参数插入
7、右值引用和移动语义
7.1、左值引用和右值引用基本介绍
1）、左值和左值引用介绍与演示
什么是左值？
说明： 左值是一个表示数据的表达式(如变量名或解引用的指针)。
①对于左值，可以获取它的地址，也能对其赋值。（PS：const修饰符的左值，不能对其赋值，但是可以取地址。）
②左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。
// 以下的p、b、c、*p(解引用指针)都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
什么是左值引用？
说明： 左值引用就是对左值进行引用，即给左值取别名。
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pv = *p;
2）、右值和右值引用介绍与演示
什么是右值？
说明： 右值也是一个表示数据的表达式，
①如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等
②右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，且右值不能取地址。
int add(int a, int b)
{
return a + b;
}
void test07()
{
int a = 1, b = 2;
//常见右值形式
10;
"string";
a + b;
add(a, b);
}
什么是右值引用？
说明： 右值引用就是对右值的引用，即给右值取别名。这里需要注意右值引用的写法。
int&& rr1 = 10;
int&& rr2 = a + b;
int&& rr3 = add(a, b);
7.2、左值引用与右值引用使用比较
1）、左值引用能引用右值吗？
1、普通情况下，左值引用只能引用左值，不能引用右值。
2、但是const左值引用既可引用左值，也可引用右值。
void test08()
{
// 左值引用只能引用左值，不能引用右值
int a = 10;
int& ra1 = a; //引用左值：right
//int& ra2 = 10; //引用右值：error
//const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10; //引用右值
const int& ra4 = a; //引用左值
}
2）、右值引用可以引用左值吗？
1、右值引用只能右值，不能引用左值。
2、但是右值引用可以引用move以后的左值。
void test08()
{
// 右值引用只能右值，不能引用左值。
int b = 8;
int&& rr1 = 10;
//int&& rr2 = b;//error
//但是右值引用可以引用move以后的左值
int&& rr3 = move(b);//right
}
3）、右值与右值引用下的取地址说明&
说明： 右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址。
相虽然x+y是右值，但作为右值引用用于存储的z实则为左值，因此可以被取地址。
double x = 1.1, y = 1.2;
&(x + y);//error
double&& z = (x + y);
&z;//right
7.3、相关应用
7.3.1、问题引入
1）、左值引用能解决哪些问题?
常见场景如下：
1、左值引用可以做参数，①其能够减少拷贝，提高效率；②也可以作为输出型参数使用。
2、左值引用可以做返回值，①其同样能够减少拷贝，提高效率；②同时，引用返回可以修改返回对象，如map::operator[]。
2）、左值引用存在的场景缺陷说明
例如:下述函数接口，实现时其返回值只能是传值返回，不用引用返回。
std::to_string
string to_string (int val);
string to_string (long val);
string to_string (long long val);
string to_string (unsigned val);
string to_string (unsigned long val);
string to_string (unsigned long long val);
string to_string (float val);
string to_string (double val);
string to_string (long double val);
当初的杨辉三角OJ题中，返回值vector也是传值返回。
//给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
//在「杨辉三角」中，每个数是它左上方和右上方的数的和。
class Solution {
public:
vector<vector<int>> generate(int numRows) {
}
};
上述这类情况，函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。
使用传值返回，会导致至少1次拷贝构造(这里需要看编译器是否做出优化，相关内容解释见之前博文)。
问题：如果就要减少传值返回带来的拷贝消耗，可以如何做？
7.3.2、解决方案一：输出型参数
1）、基本说明
1、使用全局变量：事实上这种方法并不被建议采用，会存在线程安全问题。
2、使用输出型参数：这种解决方案相对常见，只是其不太符合使用习惯。
//原先：
string to_string (int val);
string to_string (long val);
//修改为输出型参数：
void to_string(int val, string& str);
void to_stirng(long val, string& str);
//原先：
vector<vector<int>> generate(int numRows) {}
//修改为输出型参数；
void generate(int numRows, vector<vector<int>>& V) {}
7.3.3、解决方案二：右值引用（介绍移动构造和移动赋值）
1）、相关演示代码
为了方便观察，我们以下面的string类，也就是我们自己模拟实现的类来演示：(库中整体情况相同)
#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include
2）、实际演示
主要用到的代码如下：
1、拷贝构造、拷贝赋值我们很熟悉，此处不过多阐述。这里移动构造、移动赋值是通过右值引用来完成的。因此，我们的目标一是：学会移动构造、移动赋值的相关写法。 实际上，移动构造，本身也是构造函数中的一种，移动赋值，也是赋值运算符重载中的一种。
// 拷贝构造
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(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动构造：资源转移" << endl;
swap(s);
}
// 移动赋值
string& operator=(string && s)
{
cout << "string& operator=(string&& s) -- 移动赋值：资源转移" << endl;
swap(s);
return *this;
}
#include"mystring.h"
void test09()
{
mystring::string str1 = mystring::string().to_string(23012);
}
2、string(const string& s)、string& operator=(const string& s)：这里左值引用都被const修饰，那么其既可以引用左值，也能引用右值。上述代码，若我们没有实现移动构造，那么to_string(23012)，其在返回时，会自动匹配拷贝构造，形成深拷贝。移动赋值同理，不写时会自动匹配赋值重载。
to_string处传值返回，形成的拷贝构造如下：
3、string(string&& s)、string& operator=(string && s)：移动构造，实际是将参数右值的资源直接占位已有，省去了深拷贝要做的事项：由于没有新开空间拷贝数据，所以效率得到提高。
void test09()
{
mystring::string str1 = mystring::string().to_string(23012);
mystring::string str2(str1);//拷贝构造
mystring::string str3(move(str1));//移动语义
cout << endl;
}
7.3.4、一些说明
3）、相关说明
1、关于纯右值和将亡值：实际上，C++11中，右值分为纯右值和将亡值。对于内置类型的右值，将其称为纯右值；对于自定义类型的右值，将其称为将亡值。将亡值的生命周期即将结束，因此可使用资源转移，即窃取的方式，变相利用其数据资源。
2、std::move()：当需要用右值引用引用一个左值时，可以使用move函数，它的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
3、SQL容器中，各容器的构造在C++11中就提供移动构造。赋值运算符重载同理，此处可自行查阅文档。
4、此外，一些与插入相关的接口也会增加右值引用：如果传递的对象是右值对象，那么就会进行资源转移，减少拷贝。
7.4、完美转发
7.4.1、介绍模板中的&&：万能引用/引用折叠
1）、基本说明
若在模板中使用&&，如下述T&& t。这里并不表示右值引用，而是万能引用。其含义是其既能接收左值，又能接收右值。
template<typename T>
void PerfectForward(T&& t)//万能引用：其既能接收左值又能接收右值
{
Fun(t);
}
如下，使用同一个模板，但我们传入的值即有左值，又有右值，即的万能引用提供了能够接收左值引用和右值引用的能力。
void test10()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
}
2）、相关特性
我们以上述代码来验证万能引用的效果。PerfectForward会根据传入参数分别调用不同的Fun。
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<typename T>
void PerfectForward(T&& t)//万能引用：其既能接收左值又能接收右值
{
Fun(t);
}
void test10()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
}
结果如下，说明万能引用限制了参数接收的类型，使得后续使用中，都退化成了左值。左值->左值；右值->左值；const左值->const左值；const右值->const左值。正因为有这样的语法特性，也称万能引用为引用折叠。
也可以理解为用于接受的t为左值，所以后续Fun(t)获取结果为左值。
问题：若需求为在模板传递过程中，保持它原有的左值或者右值的属性，该如何做？
7.4.2、介绍完美转发
1）、基础介绍
std::forward ：完美转发。其作用是在传参的过程中保留对象原生类型属性。
如下，此处std::forward在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)//万能引用：其既能接收左值又能接收右值
{
//Fun(t);//移动折叠
Fun(std::forward<T>(t));//完美转发
}
2）、实际用途
完美转发是在模板&&中为保持其t值原有属性而提出的，当t值层层递进传递给下一层或者其它函数时，为了保持其特性，也需要使用完美转发。
此处以list为例：这里省略了一些内容。
#pragma once
#pragma once
#include
实际涉及函数如下：
//尾插
void push_back(const T& val)
{
//写法二
insert(end(), val);
}
//尾插
void push_back(T&& val)
{
//写法二
insert(end(), std::forward<T>(val));
}
//插入
iterator insert(iterator pos, const T& val)
{
//保存节点
Node* cur = pos._node;
Node* prev = cur->_prev;
//新增节点
Node* newnode = new Node(val);
//修改关系: prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
//返回值
return iterator(newnode);
}
//插入
iterator insert(iterator pos, T&& val)
{
//保存节点
Node* cur = pos._node;
Node* prev = cur->_prev;
//新增节点
Node* newnode = new Node(std::forward<T>(val));
//修改关系: prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
//返回值
return iterator(newnode);
}
//单节点
template<class T>
struct list_node
{
T _data;
list_node<T>* _prev;
list_node<T>* _next;
list_node(const T& val = T())
:_data(val)
, _prev(nullptr)
, _next(nullptr)
{}
list_node(T&& val)
:_data(std::forward<T>(val))
, _prev(nullptr)
, _next(nullptr)
{}
};
相关演示与解释：
8、新的类功能
8.1、新增默认成员函数：两个
1）、C++11下默认成员函数
在原先的C++类中，有6个默认成员函数：构造函数、析构函数、拷贝构造函数、拷贝赋值重载、取地址重载、const 取地址重载。
C++11 新增了两个默认成员函数：移动构造函数、移动赋值运算符重载。注意，默认成员函数，我们不写，编译器也会自动生成。
2）、一些说明
问题：哪些场景需要自己写移动构造、移动赋值？
回答：
1、拷贝对象需要深拷贝时，就可以自己写移动构造和移动赋值、拷贝构造和拷贝赋值。前者解决的是右值，后者可解决左值情况。
2、即使没有移动构造和移动赋值，由于拷贝构造和拷贝赋值是const左值引用，因此对于右值也能适用。
问题：什么情况下才会生成默认的移动构造、移动赋值(条件说明)？这两个默认函数具体做了哪些事情？
回答：
1、若没有显示实现移动构造函数，且没有显示实现析构函数 、拷贝构造、拷贝赋值重载，那么编译器会自动生成一个默认移动构造。
2、默认生成的移动构造函数，对于内置类型成员会按字节拷贝(浅拷贝)；对自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
3、默认移动赋值重载同理。
3）、相关演示
演示代码：
#include"mystring.h"//此处使用的是我们自己写的string，目的在于方便观察。
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()//析构
{}
private:
mystring::string _name;
int _age;
};
void test12()
{
Person s1("谢灵运",22);
Person s2 = s1;//左值
Person s3 = std::move(s1);//右值
Person s4;
s4 = std::move(s2);//右值
}
8.2、关键字
8.2.1、default和delete、如何创建一个只在堆区的
1）、基本说明
强制生成默认函数的关键字default： 当需要使用某个默认成员函数，但该函数没有默认生成时，就可以使用该关键字。
举例：当提供了拷贝构造，就不会生成移动构造，那么可以使用default关键字显示指定移动构造生成。
Person(Person&& p) = default;
Person& operator=(Person&& p) = 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& operator=(const Person& p)//赋值运算符重载
{
if (this != &p)
{
_name = p._name;
_age = p._age;
}
return *this;
}
Person(Person&& p) = default;
Person& operator=(Person&& p) = default;
~Person()//析构
{}
private:
mystring::string _name;
int _age;
};
禁止生成默认函数的关键字delete： 如果能想要限制某些默认函数的生成，在C++98中，可将该函数设置成private，这样调用时就会报错。在C++11中除了上述设置为私有成员的方法，在待限制函数的声明后加=delete，同样能达到效果，被delete修饰的函数为删除函数。
class Person
{
public:
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
Person(const Person& p) = delete;
private:
mystring::string _name;
int _age;
};
void test13()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
}
2）、如何创建一个只在堆上的类？要求使用到delete关键字
如下述，若不加约束条件，通常情况下一个类可以在多种内存区域创建。
class HeapOnly
{
private:
//……
private:
char* _str;
//...
};
void test14()
{
HeapOnly hp1;//在栈上
` static HeapOnly hp2;//在静态区
HeapOnly* ptr = new HeapOnly;//可以在堆上
}
现在，我们需要创建一个只能在堆上申请出的类，即只有HeapOnly* ptr = new HeapOnly;可成立，该如何做？
1、一种方法是将构造函数私有化，写在private类的访问限定符里，同时在public区域提供一个函数，用于外部调用，可在该函数中使用New构建类。(此法类似于之前讲述的如何设计一个只能在栈上定义的对象？详细见：类和对象(四))
2、虽然上述方法能够解决问题， 但题目要求我们使用上delete关键字。因此，这里提供一个方法：
class HeapOnly
{
public:
HeapOnly()
{
//……
}
~HeapOnly() = delete;
private:
char* _str;
//...
};
相关说明如下：
延伸问题：在上述基础上，类中动态申请一个空间，如何释放？
如下，构造函数中我们动态申请了空间，由于HeapOnly类的析构被限制，无法调用，因此_str申请到的空间并不会被释放，存在内存泄漏。同理，ptr指针我们也不能直接delete ptr，因为这样实际上也是调用了析构。
class HeapOnly
{
public:
HeapOnly()
{
_str = new char[10];
}
~HeapOnly() = delete;
private:
char* _str;
//...
};
void test14()
{
HeapOnly* ptr = new HeapOnly;//在堆上创建HeapOnly类
delete ptr;//error
}
解决方案如下：
class HeapOnly
{
public:
HeapOnly()
{
_str = new char[10];
}
~HeapOnly() = delete;
void Destroy()
{
delete[] _str;
operator delete(this);
}
private:
char* _str;
//...
};
void test14()
{
HeapOnly* ptr = new HeapOnly;
ptr->Destroy();
//operator delete(ptr);//此处效果等同于operator delete(this);
}
1、可以在类中直接使用一个Destroy()函数，我们手动释放相应空间。operator delete(this);能达到释放类的作用。实际上，它是
系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。相关介绍与回顾：内存管理和模板初阶。
2、如果此处不在Destory中调用operator delete(this);，也可以在类外使用，只需要将其换为operator delete(ptr);。
8.2.2、final和override
相关内容见继承与多态。
9、可变参数模板
9.1、基础概念介绍
1）、为什么需要可变参数模板？
函数中的可变参数：传递的是变量。可追溯到C语言，如下述printf中。
模板中的可变参数：传递的是类型。C++98/03中，类模版和函数模版中只能含固定数量的模版参数，而C++11中引入可变参数模板，使得模板参数数量不被限制死，可根据我们的需求而定。
2）、相关格式与示例
相关格式如下：下述参数args前面有省略号，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。
template <class ...Args>
void ShowList(Args... args)
{
}
1、 Args是一个模板参数包，args是一个函数形参参数包
2、声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
使用如下：用这样的类去实例化对象/使用函数时，我们能够传递不同数量的参数，且参数的类型可不同。
string str("string");
vector<int> v1;
ShowList();
ShowList(1,1.1);
ShowList(1, 1.1, 'A', str, v1);
3）、如何获取参数包大小？sizeof计算数据包个数
以上述代码为例，我们可以通过sizeof...(args) 获取到参数包的个数，这里需要注意它的写法，中间...不能省略。
template <class ...Args>
void ShowList(Args... args)
{
cout <<"当前参数包个数：" << sizeof...(args) << endl;
cout << endl;
}
void test15()
{
string str("string");
vector<int> v1;
ShowList();
ShowList(1,1.1);
ShowList(1, 1.1, 'A', str, v1);
}
实际上，args参数包底层是用数组实现的，相当于使用数组接受到这些传入的参数。但需要注意以下这种写法是不允许的：
template <class ...Args>
void ShowList(Args... args)
{
for (size_t i = 0; i < sizeof...(args); ++i)
{
cout << args[i] << " ";
}
cout << endl;
}
那么，如果我们需要获取参数包中的参数，可以如何做？
4）、如何展开参数包获取参数？递归、初始化列表推导
相关代码如下：ShowList(args...);注意这里的写法。
void ShowList()
{
cout << endl;
}
template <class T,class ...Args>
void ShowList(const T& val, Args... args)
{
cout << "ShowList(" << val << ", " << sizeof...(args) << "参数包)" << endl;
ShowList(args...);
}
void test16()
{
string str("hello");
ShowList(1, 'A', str);
ShowList(1, 'A', str, "world",3.14);
vector<int> v = { 1,2,3 };
ShowList(v[0],v[1],v[2]);
}
演示结果如下：
以ShowList(1, 'A', str, "world",3.14);为例，每次传入的首个参数作为const T& val被当前递归层取出使用（这里是打印），后续参数包又继续参与递归。
因此，①(1, 'A', str, "world",3.14)，当val=1时,args=('A', str, "world",3.14)；②递归，当val='A'时,args=(str, "world",3.14)；③如此反复递归，直到递归终止函数void ShowList()。
引入：实际上，我们查看SQL库，一些使用可变参数包的地方，并没有向上述一样需要额外提供一个参数const T& val。这里我们将介绍另一种展开参数包的方法，即使用逗号表达式。
相关代码如下：
template<class T>
int PrintArg(const T& x)
{
cout << x << " ";
return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
int a[] = { PrintArg(args)...，0 };
cout << endl;
}
void test17()
{
string str("hello");
ShowList(1, 'A', str);
ShowList(1, 'A', str, "world", 3.14);
vector<int> v = { 1,2,3 };
ShowList(v[0], v[1], v[2]);
}
分析：
1、int a[] = { PrintArg(args)...，0 }中，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成[(printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... ]，最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。
2、逗号表达式会按顺序执行逗号前面的表达式，使用{ PrintArg(args)...,0 }创建数组的过程中，会先执行逗号表达式前面的部分iPrintArg(args)，再执行0，即int a[]={0}。对于前者，其是一个函数调用，我们就可在PrintArg中依次获取到参数并使用（这里是打印）。
3、通过上述方式，在构造int数组的过程中，就将参数包展开了。
演示结果如下：
9.2、STL容器中的emplace相关接口函数
1）、基本说明
C++11中新增的两接口emplace、emplace_back，其中就使用到了可变模板参数，只是这里在其基础上增加了引用。
2）、相关使用
如下，通常情况下emplace_back和push_back用法上没什么太大的区别
vector<int> v1;
v1.push_back(1);
v1.emplace_back(2);
而如果是下述情况，对于emplace支持可变参数，拿到构建pair对象的参数后自己去创建对象，push_back则要调用make_pair先构建一个pair再返回。即emplace_back可以直接构造，push_back是先构造，再移动构造/拷贝构造。
vector<pair<mystring::string, int>> v2;
v2.push_back(make_pair("sort", 1));
v2.emplace_back(make_pair("sort", 1));
v2.emplace_back("sort", 1);
我们再用一个日期类来演示：
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{
cout << "Date(int year = 1, int month = 1, int day = 1)" << endl;
}
Date(const Date& d)
:_year(d._year)
, _month(d._month)
, _day(d._day)
{
cout << "Date(const Date& d)" << endl;
}
Date& operator=(const Date& d)
{
cout << "Date& operator=(const Date& d))" << endl;
return *this;
}
private:
int _year;
int _month;
int _day;
};
可看到emplace_back和push_back调用如下：
10、lambda表达式
10.1、问题引入
1）、能像函数一样使用的对象/类型有哪些？
回答：
1、函数指针
2、仿函数/函数对象
3、lambda
关于仿函数的使用补充：如下两处Compare都需要传递仿函数。
若仿函数是作为函数参数使用，则传递的是对象，需要在仿函数后加()，可用该仿函数创建一个对象传入，也可使用一个匿名对象。比如less。
//std::sort
template <class RandomAccessIterator, class Compare>
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
若仿函数作为模板参数使用，则传递的是类型，可以不加()，比如less 。
//std::priority_queue
template <class T, class Container = vector<T>,
class Compare = less<typename Container::value_type> > class priority_queue;
一些问题说明：
如下述，假设我们有个自定义类型，用其去定义一堆数据。比如这里的Goods商品，需要对这些数据按各种方式(名字、价格、评价、等等)进行排序。
struct Goods//货品
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
//……
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
用上述类一定一堆商品，并对其排序：
vector<Goods> v = { { "麻辣烤鱼", 39, 4.5 }, { "桥头排骨", 17, 4.8 }, { "千层蛋糕", 25, 4.9 } , { "牛油拌饭", 21, 4.7 } };
for (auto& e : v)
{
cout << e._name <<" 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
假设使用std::sort排序，则需要传递仿函数，而Goods的成员类型各有不同，这就意味着我们需要写多个仿函数用于传递：
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct CompareEvaluateGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._evaluate > gr._evaluate;
}
};
//……
演示结果如下：这意味着一旦自定义类型中成员变量很多，且其类型各有不同，那么要达成各类参数排序(各方面比较评估)，需要写多个仿函数。
void test19()
{
vector<Goods> v = { { "麻辣烤鱼", 39, 4.5 }, { "桥头排骨", 17, 4.8 }, { "千层蛋糕", 25, 4.9 } , { "牛油拌饭", 21, 4.7 } };
for (auto& e : v)
{
cout << e._name <<" 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
sort(v.begin(), v.end(), ComparePriceLess());
for (auto& e : v)
{
cout << e._name << " 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
sort(v.begin(), v.end(), CompareEvaluateGreater());
for (auto& e : v)
{
cout << e._name << " 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
}
因此，为了解决这类问题上仿函数的局限性，C++11提出了lambda表达式。
10.2、lambda表达式基本介绍
10.2.1、基本语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
介绍：
[capture-list] ：捕捉列表。该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数。捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，若不需要参数传递，则可以连同()一起省略。
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->return-type：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。PS：返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
实际如何使用见下述。
10.2.2、使用举例（基本使用、捕捉列表介绍）
1）、两数相加的lambda (如何写和如何调用)
如何写： 如下，add1、add2等号后面的两串都是两数相加的lambda。
如何调用： 可将lambda表达式理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。如下，add1、add2是用来调用该lambda表达式的。
//[捕捉列表](参数列表)mutable->返回值类型 {函数体};
auto add1=[](int a, int b)->int {return a + b; };
cout << add1(1, 2) << endl;
auto add2 = [](double x, double y) {return x + y; };//返回值类型明确情况下，可省略返回类型由编译器自动推导
cout << add2(1.1, 2.2) << endl;
2）、交换变量的lambda (多行说明、无参说明)
如下，①若无返回值，可省略，也可写为->void；②可以看到函数体比较冗杂，这时候写为一排观察起来不太方便。
auto swap1 = [](int& val1, int& val2)->void { int tmp = val1; val1 = val2; val2 = tmp; };
int x1 = 6, x2 = 3;
swap1(x1, x2);
cout << x1 << " " << x2 << endl;
因此，我们也可以如下，将函数体部分换行写：
auto swap2 = [] (char& ch1, char& ch2)
{
char tmp = ch1;
ch1 = ch2;
ch2 = tmp;
};
char c1 = 'z', c2 = 'w';
swap2(c1, c2);
cout << c1 << " " << c2 << endl;
3）、不传参数交换变量的lambda（介绍捕捉列表）
不传递参数，则可以使用捕捉列表达成：
如下述代码：
int x1 = 6, x2 = 3;
cout << x1 << " " << x2 << endl;
auto swap1 = [x1, x2]()mutable
{
x1 = 5;
int tmp = x1;
x1 = x2;
x2 = tmp;
};
swap1();
cout << x1 << " " << x2 << endl;
auto swap2 = [&x1,&x2] ()mutable
{
int tmp = x1;
x1 = x2;
x2 = tmp;
};
swap2();
cout << x1 << " " << x2 << endl;
对捕捉列表的介绍：
1、捕捉方式说明：捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针
2、相关注意事项：
Ⅰ. 父作用域指包含lambda函数的语句块
Ⅱ. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
举例一：[=, &a,&b]，以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。
举例二：[&，a,this]，值传递方式捕捉变量a和this，引用方式捕捉其他变量。
Ⅲ.捕捉列表不允许变量重复传递，否则就会导致编译错误。
举例一：[=, a]，=已经以值传递方式捕捉了所有变量，则此处单独列出a属于重复捕捉。
Ⅳ、 在块作用域以外的lambda函数捕捉列表必须为空。
Ⅴ、 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
Ⅶ、lambda表达式之间不能相互赋值，即使看起来类型相同
10.2.3、示例演示
1）、修改上述问题引入
如下此例，之前我们使用的是仿函数，现在让我们将其修改为lambda表达式。
struct Goods//货品
{
string _name; // 名字
double _price; // 价格
double _evaluate; // 评价
Goods(const char* str, double price, double evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
void test19()
{
vector<Goods> v = { { "麻辣烤鱼", 39, 4.5 }, { "桥头排骨", 17, 4.8 }, { "千层蛋糕", 25, 4.9 } , { "牛油拌饭", 21, 4.7 } };
for (auto& e : v)
{
cout << e._name <<" 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
}
修改结果如下：
void test22()
{
vector<Goods> v = { { "麻辣烤鱼", 39, 4.5 }, { "桥头排骨", 17, 4.8 }, { "千层蛋糕", 25, 4.9 } , { "牛油拌饭", 21, 4.7 } };
for (auto& e : v)
{
cout << e._name << " 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
for (auto& e : v)
{
cout << e._name << " 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; });
for (auto& e : v)
{
cout << e._name << " 价格：" << e._price << " 评价：" << e._evaluate << endl;
}
cout << endl;
}
10.2.4、相关底层
class Rate
{
public:
Rate(double rate) : _rate(rate)
{}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
void test23()
{
// 函数对象
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);
}
对函数对象： 可以像函数一样使用的对象。在它的类中重载了operator()运算符，使其调用方式和函数类似，因此又称为仿函数。
对lambda表达式： 实际底层中，编译器对其处理方式与函数对象的处理方式相同。即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
①这个生成的类名称为lambda+uuid，用于区别；②在捕获参数时，就是把对应参数传递给operator()。
11、包装器
11.1、function
11.1.1、问题引入：为什么
1）、问题引入
问题：如下述这样一个代码，func可以是什么？
回答：①可以是一个函数；②可以是一个仿函数(函数对象)；③可以是一个lambda表达式。
ret = func(x);
问题：它会存在什么问题？
回答：效率问题，体现在模板实例化中。
如下述代码，我们创建一个useF 的模板，F f传入类似于上述的func， T x是func中的参数值。
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);
}
现在，使用这个模板进行实例化，其第一参数分别为函数f、仿函数Functor、lambda表达式，第二参数相同。问题：模板实例化时，会实例化一份，还是不同的三份？static int count可帮助我们检验相关结果，若实例化一份，静态变量count应是同一个。
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
void test24()
{
// 传入函数
cout << useF(f, 5.20) << endl;
cout << endl;
// 传入仿函数
cout << useF(Functor(), 5.20) << endl;
cout << endl;
// 传入lamber表达式
cout << useF([](double d)->double { return d / 4; }, 5.20) << endl;
cout << endl;
}
验证如下：useF函数模板实例化了三份。这种多类型调用一定程度上会带来模板的效率低下，实例化多份的问题。
由此引出了下述关于包装器的内容。
11.1.2、基本格式：是什么
1）、基本说明
function包装器：也称为适配器，C++中的function本质是一个类模板。相关链接：std::function，其在头文件
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 普通模板参数，作为被调用函数的返回类型。
Args…：模板参数包，作为被调用函数的形参。
2）、基本使用演示
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
double operator() (double a, double 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;
}
};
void test25()
{
//class function F4 = Plus::plusd();//error
function<double(Plus,double, double)> F4 = &Plus::plusd;
cout << F4(Plus(), 1, 3) << endl;
//1、语法规定取非静态成员函数的地址，需要加&。
//2、成员函数的指针不能直接调用，需要传递对象。
//3、此处可用bind解决。
//使用function包装一个lambda表达式
function<int(int)> F5 = [](int i)->int {return i * i; };
cout << F5(3) << endl;
}
11.1.3、问题解决：有什么用
1）、针对问题引入的修改
基于上述演示，我们将问题引入部分进行修改：
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;
}
};
void test26()
{
//包装函数
function<double(double)> F1 = f;
//包装仿函数
function<double(double)> F2 = Functor();
//包装lamber表达式
function<double(double)> F3 = [](double d)->double { return d / 4; };
//传入函数
cout << useF(F1, 5.20) << endl;
cout << endl;
//传入仿函数
cout << useF(F2, 5.20) << endl;
cout << endl;
//传入lamber表达式
cout << useF(F3, 5.20) << endl;
cout << endl;
}
11.2、bind
11.2.1、基本说明
1）、问题引入
根据上述，对于类的非静态成员函数，在使用function包装时，需要额外传递类。这样即使在包装后，使用类模板实例化不同类型时，就不能达到只实例化一份的效果。
//使用function包装一个类非静态成员函数
//function F4 = Plus::plusd();//error
function<double(Plus,double, double)> F4 = &Plus::plusd;
cout << F4(Plus(), 1, 3) << endl;
//1、语法规定取非静态成员函数的地址，需要加&。
//2、成员函数的指针不能直接调用，需要传递对象。
//3、此处可用bind解决。
2）、基本说明
std::bind：定义在头文件
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。
11.2.2、使用演示
1）、调整参数顺序
演示代码如下：传入的都是x,y，获取到的结果不同。
int Div(int a, int b)
{
return a / b;
}
//using namespace placeholders;
//此处展开是方便placeholders::_1, placeholders::_2直接写为_1,_2
void test27()
{
调整顺序
int x = 20, y = 10;
cout << Div(x, y) << endl;
//_1 _2.... 定义在placeholders命名空间中，代表绑定函数对象的形参
bind(Div, placeholders::_1, placeholders::_2);
auto bindFunc1 = bind(Div, _1, _2);//可以直接使用auto自动推导
function<int(int, int)> bindFunc2 = bind(Div, _2, _1);//也可以上一层包装器
cout << bindFunc1(x, y) << endl;
cout << bindFunc2(x, y) << endl;
}
演示结果如下：
1、bind(Div, placeholders::_1, placeholders::_2);，对Div进行绑定，_1代表Div的形参a，_2代表Div的形参b。
2、对bindFunc1(x, y)，有bindFunc1 = bind(Div, _1, _2)，则x对应于_1，即形参a，y对应于_2，即形参b。因此结果为x/y。
3、对bindFunc2(x, y)，有bindFunc2 = bind(Div, _2, _1)，则x对应于_2，即形参b，y对应于_1，即形参a。因此结果为y/x。
2）、调整个数：解决上述非静态成员函数与普通函数同时使用一个类实例化的问题
相比于上述调整顺序，bind一般用于调整个数。演示代码如下：
int Div(int a, int b)
{
return a / b;
}
int Plus(int a, int b)
{
return a + b;
}
int Mul(int a, int b, double rate)
{
return a * b * rate;
}
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
①、如果此时使用funtion包装，对于非静态成员函数sub，则需要多传递一个参数，即function
②、同样，这里由于Mul有三个参数，包装时为：function
③、假设我们的需求为让上述几个函数都能使用同样的模板，比如下述的map，那么就可用bind解决。bind使用于绑定固定参数，从而达到调整个数的效果，但其局限在与所绑定的参数在实际使用中是固定的，没有修改需求。
using namespace placeholders;
void test27()
{
调整个数
function<int(int, int)> funcPlus = Plus;
//function funcSub = &Sub::sub;
function<int(int, int)> funcSub = bind(&Sub::sub, Sub(), _1, _2);//把第一个参数绑死，即Sub()
function<int(int, int)> funcMul = bind(Mul, _1, _2, 1.5);//把第三个参数绑死，即rate
map<string, function<int(int, int)>> opFuncMap =
{
{ "+", Plus},
{ "-", bind(&Sub::sub, Sub(), _1, _2)}
};
cout << funcPlus(1, 2) << endl;
cout << funcSub(1, 2) << endl;
cout << funcMul(2, 2) << endl;
cout << opFuncMap["+"](1, 2) << endl;
cout << opFuncMap["-"](1, 2) << endl;
}
12、多线程
待补。
1）、基本说明