简单大气的网站,手机在线销售网站 - 百度,适合夫妻看的哔哩哔哩电视剧,淘宝店的网站建设分析目录 1.C11简介
2.列表初始化
3.声明
1.auto
2.decltype
3.nullptr
4.范围for循环
5.智能指针
6.STL的一些变化
7.右值引用和移动语义
1.左值引用和右值引用
2.左值引用和右值引用的比较
3.右值引用的使用场景和意义
4.右值引用引用左值及其一些更深入的使用场景分…目录 1.C11简介
2.列表初始化
3.声明
1.auto
2.decltype
3.nullptr
4.范围for循环
5.智能指针
6.STL的一些变化
7.右值引用和移动语义
1.左值引用和右值引用
2.左值引用和右值引用的比较
3.右值引用的使用场景和意义
4.右值引用引用左值及其一些更深入的使用场景分析
5.完美转发
8.类的新功能
9.可变模板参数
10.lambda表达式
1.lambda表达式
2.lambda表达式语法
3.捕获列表说明
4.函数对象与lambda表达式
11.包装器
12.线程库
1.thread类的简单介绍
2.线程函数参数
3.原子性操作库(atomic)
4.lock_guard与unique_lock
1.mutex的种类
2.lock_guard
3.unique_lock
5.支持两个线程交替打印一个打印奇数一个打印偶数 1.C11简介 在2003年C标准委员会曾经提交了一份技术勘误表(简称TC1)使得C03这个名字已经取代了 C98称为C11之前的最新C标准名称。不过由于C03(TC1)主要是对C98标准中的漏洞进行修复语言的核心部分则没有改动因此人们习惯性的把两个标准合并称为C98/03标准 从C0x到C11C标准10年磨一剑第二个真正意义上的标准珊珊来迟。相比于 C98/03C11则带来了数量可观的变化其中包含了约140个新特性以及对C03标准中 约600个缺陷的修正这使得C11更像是从C98/03中孕育出的一种新语言。相比较而言 C11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全不仅功能更 强大而且能提升程序员的开发效率公司实际项目开发中也用得比较多所以我们要作为一个 重点去学习。C11增加的语法特性非常篇幅非常多我们这里没办法一 一讲解所以主要讲解实际中比较实用的语法
C11文档
2.列表初始化
1.{ }初始化 在C98中标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定
struct Point
{int _x;int _y;
};int main()
{int array1[] { 1, 2, 3, 4, 5 };int array2[5] { 0 };Point p { 1, 2 };return 0;
} C11扩大了用大括号括起的列表(初始化列表)的使用范围使其可用于所有的内置类型和用户自 定义的类型使用初始化列表时可添加等号()也可不添加
struct Point
{int _x;int _y;
};int main()
{int x1 1;int x2{ 2 };int array1[]{ 1, 2, 3, 4, 5 };int array2[5]{ 0 };Point p{ 1, 2 };// C11中列表初始化也可以适用于new表达式中int* pa new int[4]{ 0 };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(2022, 1, 1); // old style// C11支持的列表初始化这里会调用构造函数初始化Date d2{ 2022, 1, 2 };Date d3 { 2022, 1, 3 };return 0;
}2.initializer_list
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一般是作为构造函数的参数C11对STL中的不少容器就增加 std::initializer_list作为参数的构造函数这样初始化容器对象就更方便了。也可以作为operator 的参数这样就可以用大括号赋值
3.声明
1.auto 在C98中auto是一个存储类型的说明符表明变量是局部自动存储类型但是局部域中定义局 部的变量默认就是自动存储类型所以auto就没什么价值了。C11中废弃auto原来的用法将其用于实现自动类型推断。这样要求必须进行显示初始化让编译器将定义对象的类型设置为初 始化值的类型
int main()
{int i 10;auto p i;auto pf strcpy;cout typeid(p).name() endl;cout typeid(pf).name() endl;mapstring, string dict { {sort, 排序}, {insert, 插入} };//mapstring, string::iterator it dict.begin();auto it dict.begin();return 0;
}2.decltype 关键字decltype将变量的类型声明为表达式指定的类型
// decltype的一些使用使用场景
templateclass T1, class T2
void F(T1 t1, T2 t2)
{decltype(t1 * t2) ret;cout typeid(ret).name() endl;
}int main()
{const int x 1;double y 2.2;decltype(x * y) ret; // ret的类型是doubledecltype(x) p; // p的类型是int*cout typeid(ret).name() endl;cout typeid(p).name() endl;F(1, a);return 0;
}3.nullptr 由于C中NULL被定义成字面量0这样就可能回带来一些问题因为0既能指针常量又能表示 整形常量。所以出于清晰和安全的角度考虑C11中新增了nullptr用于表示空指针
4.范围for循环 范围for循环在STL的容器中已经详细讲解,在这里不做过多的解释
5.智能指针 智能指针在后续会专门讲解,在这里先不做解释
6.STL的一些变化 圈出的便是新增的容器
容器中的一些新方法 如果我们再细细去看会发现基本每个容器中都增加了一些C11的方法但是其实很多都是用得 比较少的。 比如提供了cbegin和cend方法返回const迭代器等等但是实际意义不大因为begin和end也是 可以返回const迭代器的 实际上C11更新后容器中增加的新方法最后用的插入接口函数的右值引用版本 但是这些接口到底意义在哪网上都说他们能提高效率他们是如何提高效率的
在下面的右值引用会对其进行讲解
7.右值引用和移动语义
1.左值引用和右值引用 传统的C语法中就有引用的语法而C11中新增了的右值引用语法特性所以从现在开始我们 之前学习的引用就叫做左值引用。无论左值引用还是右值引用都是给对象取别名
什么是左值什么是左值引用 左值是一个表示数据的表达式(如变量名或解引用的指针)我们可以获取它的地址可以对它赋 值左值可以出现赋值符号的左边右值不能出现在赋值符号左边。定义时const修饰符后的左 值不能给他赋值但是可以取它的地址。左值引用就是给左值的引用给左值取别名
int main()
{// 以下的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 pvalue *p;return 0;
}
什么是右值什么是右值引用 右值也是一个表示数据的表达式如字面常量、表达式返回值函数返回值(这个不能是左值引用返回)等等右值可以出现在赋值符号的右边但是不能出现出现在赋值符号的左边右值不能取地址。右值引用就是对右值的引用给右值取别名
int main()
{double x 1.1, y 2.2;// 以下几个都是常见的右值10;x y;fmin(x, y);// 以下几个都是对右值的右值引用int rr1 10;double rr2 x y;double rr3 fmin(x, y);// 这里编译会报错error C2106: “”: 左操作数必须为左值10 1;x y 1;fmin(x, y) 1;return 0;
} 需要注意的是右值是不能取地址的但是给右值取别名后会导致右值被存储到特定位置且可以取到该位置的地址也就是说例如不能取字面量10的地址但是rr1引用后可以对rr1取地 址也可以修改rr1。如果不想rr1被修改可以用const int rr1 去引用是不是感觉很神奇 这个了解一下实际中右值引用的使用场景并不在于此这个特性也不重要
int main()
{double x 1.1, y 2.2;int rr1 10;const double rr2 x y;rr1 20;rr2 5.5; // 报错return 0;
}
2.左值引用和右值引用的比较
左值引用总结:
左值引用只能引用左值不能引用右值但是const左值引用既可引用左值也可引用右值
int main()
{// 左值引用只能引用左值不能引用右值。int a 10;int ra1 a; // ra为a的别名//int ra2 10; // 编译失败因为10是右值// const左值引用既可引用左值也可引用右值。const int ra3 10;const int ra4 a;return 0;
}
右值引用总结:
右值引用只能右值不能引用左值但是右值引用可以move以后的左值
int main()
{// 右值引用只能右值不能引用左值。int r1 10;// error C2440: “初始化”: 无法从“int”转换为“int ”// message : 无法将左值绑定到右值引用int a 10;int r2 a;// 右值引用可以引用move以后的左值int r3 std::move(a);return 0;
}3.右值引用的使用场景和意义 前面我们可以看到左值引用既可以引用左值和又可以引用右值那为什么C11还要提出右值引用呢是不是化蛇添足呢下面我们来看看左值引用的短板右值引用是如何补齐这个短板的
namespace bit
{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){::swap(_str, s._str);::swap(_size, s._size);::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(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;}~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};
}左值引用的场景 做参数和做返回值都可以提高效率
void func1(bit::string s)
{}void func2(const bit::string s)
{}int main()
{bit::string s1(hello world);// func1和func2的调用我们可以看到左值引用做参数减少了拷贝提高效率的使用场景和价值func1(s1);func2(s1);// string operator(char ch) 传值返回存在深拷贝// string operator(char ch) 传左值引用没有拷贝提高了效率s1 !;return 0;
}
左值引用的短板 但是当函数返回对象是一个局部变量出了函数作用域就不存在了就不能使用左值引用返回 只能传值返回。例如bit::string to_string(int value)函数中可以看到这里只能使用传值返回 传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造) namespace bit
{bit::string to_string(int value){bool flag true;if (value 0){flag false;value 0 - value;}bit::string str;while (value 0){int x value % 10;value / 10;str (0 x);}if (flag false){str -;}std::reverse(str.begin(), str.end());return str;}
}int main()
{bit::string ret1 bit::to_string(1234);bit::string ret2 bit::to_string(-1234);return 0;
} 右值引用和移动语义解决上述问题 在bit::string中增加移动构造移动构造本质是将参数右值的资源窃取过来占位已有那么就不用做深拷贝了所以它叫做移动构造就是窃取别人的资源来构造自己 在bit::string中增加移动构造移动构造本质是将参数右值的资源窃取过来占位已有那么就不用做深拷贝了所以它叫做移动构造就是窃取别人的资源来构造自己
// 移动构造
string(string s):_str(nullptr),_size(0),_capacity(0)
{cout string(string s) -- 移动语义 endl;swap(s);
}int main()
{bit::string ret2 bit::to_string(-1234);return 0;
} 再运行上面bit::to_string的两个调用我们会发现这里没有调用深拷贝的拷贝构造而是调用 了移动构造移动构造中没有新开空间拷贝数据所以效率提高了 不仅仅有移动构造还有移动赋值 在bit::string类中增加移动赋值函数再去调用bit::to_string(1234)不过这次是将 bit::to_string(1234)返回的右值对象赋值给ret1对象这时调用的是移动构造
// 移动赋值
string operator(string s)
{cout string operator(string s) -- 移动语义 endl;swap(s);return *this;
}int main()
{bit::string ret1;ret1 bit::to_string(1234);return 0;
}这里运行后我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象 接收编译器就没办法优化了。bit::to_string函数中会先用str生成构造生成一个临时对象但是 我们可以看到编译器很聪明的在这里把str识别成了右值调用了移动构造。然后在把这个临时 对象做为bit::to_string函数调用的返回值赋值给ret1这里调用的移动赋值
4.右值引用引用左值及其一些更深入的使用场景分析 按照语法右值引用只能引用右值但右值引用一定不能引用左值吗因为有些场景下可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时可以通过move 函数将左值转化为右值。C11中std::move()函数位于头文件中该函数名字具有迷惑性 它并不搬移任何东西唯一的功能就是将一个左值强制转化为右值引用然后实现移动语义
templateclass _Ty
inline typename remove_reference_Ty::type move(_Ty _Arg) _NOEXCEPT
{// forward _Arg as movablereturn ((typename remove_reference_Ty::type)_Arg);
}int main()
{bit::string s1(hello world);// 这里s1是左值调用的是拷贝构造bit::string s2(s1);// 这里我们把s1 move处理以后, 会被当成右值调用移动构造// 但是这里要注意一般是不要这样用的因为我们会发现s1的// 资源被转移给了s3s1被置空了。bit::string s3(std::move(s1));return 0;
}STL容器插入接口函数也增加了右值引用版本
5.完美转发
模板中的 万能引用
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; }
// 模板中的不代表右值引用而是万能引用其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
// 但是引用类型的唯一作用就是限制了接收的类型后续使用中都退化成了左值
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发templatetypename T
void PerfectForward(T t)
{Fun(t);
}int main()
{PerfectForward(10); // 右值int a;PerfectForward(a); // 左值PerfectForward(std::move(a)); // 右值const int b 8;PerfectForward(b); // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}std::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; }
// std::forwardT(t)在传参的过程中保持了t的原生类型属性。
templatetypename T
void PerfectForward(T t)
{Fun(std::forwardT(t));
}int main()
{PerfectForward(10); // 右值int a;PerfectForward(a); // 左值PerfectForward(std::move(a)); // 右值const int b 8;PerfectForward(b); // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}
8.类的新功能
默认成员函数
原来C类中有6个默认成员函数
构造函数析构函数拷贝构造函数拷贝赋值重载取地址重载const 取地址重载
C11 新增了两个移动构造函数和移动赋值运算符重载
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下
如果你没有自己实现移动构造函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任 意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数对于内置类 型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员是否实现移动构造 如果实现了就调用移动构造没有实现就调用拷贝构造如果你没有自己实现移动赋值重载函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中 的任意一个那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数对于内 置类型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员是否实现移动赋 值如果实现了就调用移动赋值没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造 完全类似)如果你提供了移动构造或者移动赋值编译器不会自动提供拷贝构造和拷贝赋值
强制生成默认函数的关键字default: C11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数但是因为一些原 因这个函数没有默认生成。比如我们提供了拷贝构造就不会生成移动构造了那么我们可以使用default关键字显示指定移动构造生成
Person(Person p) default;
禁止生成默认函数的关键字delete: 如果能想要限制某些默认函数的生成在C98中是该函数设置成private并且只声明这样只要其他人想要调用就会报错。在C11中更简单只需在该函数声明加上delete即可该语法指示编译器不生成对应函数的默认版本称delete修饰的函数为删除函数
Person(const Person p) delete;
继承和多态中的final与override关键字
多态和继承中已经讲解,在此不做解释
9.可变模板参数 C11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板相比 C98/03类模版和函数模版中只能含固定数量的模版参数可变模版参数无疑是一个巨大的改 进。然而由于可变模版参数比较抽象使用起来需要一定的技巧所以这块还是比较晦涩的。现 阶段呢我们掌握一些基础的可变参数模板特性就够我们用了
下面就是一个基本可变参数的函数模板
// Args是一个模板参数包args是一个函数形参参数包
// 声明一个参数包Args...args这个参数包中可以包含0到任意个模板参数。
template class ...Args
void ShowList(Args... args)
{} 上面的参数args前面有省略号所以它就是一个可变模版参数我们把带省略号的参数称为“参数包”它里面包含了0到NN0个模版参数。我们无法直接获取参数包args中的每个参数的 只能通过展开参数包的方式来获取参数包中的每个参数这是使用可变模版参数的一个主要特点也是最大的难点即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变 参数所以我们的用一些奇招来一一获取参数包的值
递归函数方式展开参数包
// 递归终止函数
template class T
void ShowList(const T t)
{cout t endl;
}// 展开函数
template class T, class ...Args
void ShowList(T value, Args... args)
{cout value ;ShowList(args...);
}int main()
{ShowList(1);ShowList(1, A);ShowList(1, A, std::string(sort));return 0;
}
逗号表达式展开参数包 这种展开参数包的方式不需要通过递归终止函数是直接在expand函数体中展开的, printarg不是一个递归终止函数只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式 expand函数中的逗号表达式(printarg(args), 0)也是按照这个执行顺序先执行 printarg(args)再得到逗号表达式的结果0。同时还用到了C11的另外一个特性——初始化列 表通过初始化列表来初始化一个变长数组, {(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 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;
}10.lambda表达式
在C98中如果想要对一个数据集合中的元素进行排序可以使用std::sort方法
#include algorithm
#include functional
int main()
{int array[] {4,1,8,5,3,7,0,9,2,6};// 默认按照小于比较排出来结果是升序std::sort(array, arraysizeof(array)/sizeof(array[0]));// 如果需要降序需要改变元素的比较规则std::sort(array, array sizeof(array) / sizeof(array[0]), greaterint());return 0;
}如果待排序元素为自定义类型需要用户定义排序时的比较规则
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;}
};随着C语法的发展人们开始觉得上面的写法太复杂了每次为了实现一个algorithm算法 都要重新去写一个类如果每次比较的逻辑不一样还要去实现多个类特别是相同类的命名 这些都给编程者带来了极大的不便。因此在C11语法中出现了Lambda表达式
1.lambda表达式
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;
});上述代码就是使用C11中的lambda表达式来解决可以看出lambda表达式实际是一个匿名函数
2.lambda表达式语法
lambda表达式书写格式[capture-list] (parameters) mutable - return-type { statement }
[capture-list] : 捕捉列表该列表总是出现在lambda函数的开始位置编译器根据[]来 判断接下来的代码是否为lambda函数捕捉列表能够捕捉上下文中的变量供lambda 函数使用(parameters)参数列表。与普通函数的参数列表一致如果不需要参数传递则可以连同()一起省略mutable默认情况下lambda函数总是一个const函数mutable可以取消其常量性。使用该修饰符时参数列表不可省略(即使参数为空)-returntype返回值类型。用追踪返回类型形式声明函数的返回值类型没有返回值时此部分可省略。返回值类型明确情况下也可省略由编译器对返回类型进行推 导{statement}函数体。在该函数体内除了可以使用其参数外还可以使用所有捕获到的变量
注意 在lambda函数定义中参数列表和返回值类型都是可选部分而捕捉列表和函数体可以为 空。因此C11中最简单的lambda函数为[]{}; 该lambda函数不能做任何事情
int main()
{// 最简单的lambda表达式, 该lambda表达式没有任何意义[]{}; // 省略参数列表和返回值类型返回值类型由编译器推导为intint a 3, b 4;[]{return a 3; }; // 省略了返回值类型无返回值类型auto fun1 [](int c){b a c; }; fun1(10)couta bendl;// 各部分都很完善的lambda函数auto fun2 [, b](int c)-int{return b a c; }; coutfun2(10)endl;// 复制捕捉xint x 10;auto add_x [x](int a) mutable { x * 2; return a x; }; cout add_x(10) endl; return 0;
}
3.捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用以及使用的方式传值还是传引用
[var]表示值传递方式捕捉变量var[]表示值传递方式捕获所有父作用域中的变量(包括this)[var]表示引用传递捕捉变量var[]表示引用传递捕捉所有父作用域中的变量(包括this)[this]表示值传递方式捕捉当前的this指针
注意:
父作用域指包含lambda函数的语句块语法上捕捉列表可由多个捕捉项组成并以逗号分割.[, a, b],以引用传递的方式捕捉变量a和b值传递方式捕捉其他所有变量捕捉列表不允许变量重复传递否则就会导致编译错误,[, a]已经以值传递方式捕捉了所有变量捕捉a重复在块作用域以外的lambda函数捕捉列表必须为空在块作用域中的lambda函数仅能捕捉父作用域中局部变量捕捉任何非此作用域或者非局部变量都lambda表达式之间不能相互赋值即使看起来类型相同
4.函数对象与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);// lamberauto r2 [](double monty, int year)-double{return monty*rate*year;};r2(10000, 2);return 0;
}
从使用方式上来看函数对象与lambda表达式完全一样 函数对象将rate作为其成员变量在定义对象时给出初始值即可lambda表达式通过捕获列表可以直接将该变量捕获到 实际在底层编译器对于lambda表达式的处理方式完全就是按照函数对象的方式处理的即如果定义了一个lambda表达式编译器会自动生成一个类在该类中重载了operator()
11.包装器
function包装器
function包装器 也叫作适配器。C中的function本质是一个类模板也是一个包装器
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为第二个参数以此类推
12.线程库
1.thread类的简单介绍 在C11之前涉及到多线程问题都是和平台相关的比如windows和linux下各有自己的接 口这使得代码的可移植性比较差。C11中最重要的特性就是对线程进行支持了使得C在 并行编程时不需要依赖第三方库而且在原子操作中还引入了原子类的概念。要使用标准库中的线程必须包含 thread 头文件
线程类
注意:
线程是操作系统中的一个概念线程对象可以关联一个线程用来控制线程以及获取线程的 状态当创建一个线程对象后没有提供线程函数该对象实际没有对应任何线程
#include thread
int main()
{std::thread t1;cout t1.get_id() endl;return 0;
} get_id()的返回值类型为id类型id类型实际为std::thread命名空间下封装的一个类该类中 包含了一个结构体
typedef struct
{ /* thread identifier for Win32 */void *_Hnd; /* Win32 HANDLE */unsigned int _Id;
} _Thrd_imp_t; 3.当创建一个线程对象后并且给线程关联线程函数该线程就被启动与主线程一起运行。 线程函数一般情况下可按照以下三种方式提供
函数指针lambda表达式函数对象
#include iostream
using namespace std;
#include thread
void ThreadFunc(int a)
{cout Thread1 a endl;
}class TF
{public:void operator()(){cout Thread3 endl;}
};int main()
{// 线程函数为函数指针thread t1(ThreadFunc, 10);// 线程函数为lambda表达式thread t2([]{cout Thread2 endl; });// 线程函数为函数对象TF tf;thread t3(tf);t1.join();t2.join();t3.join();cout Main thread! endl;return 0;
} 4.thread类是防拷贝的不允许拷贝构造以及赋值但是可以移动构造和移动赋值即将一个 线程对象关联线程的状态转移给其他线程对象转移期间不意向线程的执行 5.可以通过jionable()函数判断线程是否是有效的如果是以下任意情况则线程无效
采用无参构造函数构造的线程对象线程对象的状态已经转移给其他线程对象线程已经调用jion或者detach结束
2.线程函数参数 线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的因此即使线程参数为引用类型在线程中修改后也不能修改外部实参因为其实际引用的是线程栈中的拷贝而不是外部实参
#include thread
void ThreadFunc1(int x)
{x 10;
}void ThreadFunc2(int* x)
{*x 10;
}int main()
{int a 10;// 在线程函数中对a修改不会影响外部实参因为线程函数参数虽然是引用方式但其实际
引用的是线程栈中的拷贝thread t1(ThreadFunc1, a);t1.join();cout a endl;// 如果想要通过形参改变外部实参时必须借助std::ref()函数thread t2(ThreadFunc1, std::ref(a);t2.join();cout a endl;// 地址的拷贝thread t3(ThreadFunc2, a);t3.join();cout a endl;return 0;
}注意:如果是类成员函数作为线程参数时必须将this作为线程函数参数
3.原子性操作库(atomic) 多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的那么没问题因为只读操作不会影响到数据更不会涉及对数据的修改所以所有线程都会获得同样的数 据。但是当一个或多个线程要修改共享数据时就会产生很多潜在的麻烦,比如
#include iostream
using namespace std;
#include thread
unsigned long sum 0L;
void fun(size_t num)
{for (size_t i 0; i num; i)sum;
}int main()
{cout Before joining,sum sum std::endl;thread t1(fun, 10000000);thread t2(fun, 10000000);t1.join();t2.join();cout After joining,sum sum std::endl;return 0;
}C98中传统的解决方式可以对共享修改的数据可以加锁保护
#include iostream
using namespace std;
#include thread
#include mutex
std::mutex m;
unsigned long sum 0L;void fun(size_t num)
{for (size_t i 0; i num; i){m.lock();sum;m.unlock();}
}int main()
{cout Before joining,sum sum std::endl;thread t1(fun, 10000000);thread t2(fun, 10000000);t1.join();t2.join();cout After joining,sum sum std::endl;return 0;
} 虽然加锁可以解决但是加锁有一个缺陷就是只要一个线程在对sum时其他线程就会被阻 塞会影响程序运行的效率而且锁如果控制不好还容易造成死锁 因此C11中引入了原子操作。所谓原子操作即不可被中断的一个或一系列操作C11引入 的原子操作类型使得线程间数据的同步变得非常高效
#include iostream
using namespace std;
#include thread
#include atomic
atomic_long sum{ 0 };
void fun(size_t num)
{for (size_t i 0; i num; i)sum ; // 原子操作
}int main()
{cout Before joining, sum sum std::endl;thread t1(fun, 1000000);thread t2(fun, 1000000);t1.join();t2.join();cout After joining, sum sum std::endl;return 0;
}在C11中程序员不需要对原子类型变量进行加锁解锁操作线程能够对原子类型变量互斥的访问 更为普遍的程序员可以使用atomic类模板定义出需要的任意原子类型
atmoicT t; // 声明一个类型为T的原子类型变量t 注意原子类型通常属于资源型数据多个线程只能访问单个原子类型的拷贝因此在C11 中原子类型只能从其模板参数中进行构造不允许原子类型进行拷贝构造、移动构造以及operator等为了防止意外标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算 符重载默认删除掉了
4.lock_guard与unique_lock 在多线程环境下如果想要保证某个变量的安全性只要将其设置成对应的原子类型即可即高效又不容易出现死锁问题。但是有些情况下我们可能需要保证一段代码的安全性那么就只能通过锁的方式来进行控制 比如一个线程对变量number进行加一100次另外一个减一100次每次操作加一或者减一之 后输出number的结果要求number最后的值为1
#include thread
#include mutex
int number 0;
mutex g_lock;int ThreadProc1()
{for (int i 0; i 100; i){g_lock.lock();number;cout thread 1 : number endl;g_lock.unlock();}return 0;
}int ThreadProc2()
{for (int i 0; i 100; i){g_lock.lock();--number;cout thread 2 : number endl;g_lock.unlock();}return 0;
}int main()
{thread t1(ThreadProc1);thread t2(ThreadProc2);t1.join();t2.join();cout number: number endl;system(pause);return 0;
} 上述代码的缺陷锁控制不好时可能会造成死锁最常见的比如在锁中间代码返回或者在锁 的范围内抛异常。因此C11采用RAII的方式对锁进行了封装即lock_guard和unique_lock
1.mutex的种类
在C11中Mutex总共包了四个互斥量的种类 1. std::mutex C11提供的最基本的互斥量该类的对象之间不能拷贝也不能进行移动。mutex最常用 的三个函数 注意线程函数调用lock()时可能会发生以下三种情况
如果该互斥量当前没有被锁住则调用线程将该互斥量锁住直到调用 unlock之前 该线程一直拥有该锁如果当前互斥量被其他线程锁住则当前的调用线程被阻塞住如果当前互斥量被当前调用线程锁住则会产生死锁(deadlock)
线程函数调用try_lock()时可能会发生以下三种情况
如果当前互斥量没有被其他线程占有则该线程锁住互斥量直到该线程调用 unlock 释放互斥量如果当前互斥量被其他线程锁住则当前调用线程返回 false而并不会被阻塞掉如果当前互斥量被当前调用线程锁住则会产生死锁(deadlock) 2.std::recursive_mutex 其允许同一个线程对互斥量多次上锁即递归上锁来获得对互斥量对象的多层所有权 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()除此之外 std::recursive_mutex的特性和 std::mutex 大致相同 3. std::timed_mutex 比 std::mutex 多了两个成员函数try_lock_for()try_lock_until() try_lock_for() 接受一个时间范围表示在这一段时间范围之内线程如果没有获得锁则被阻塞住与 std::mutex 的 try_lock() 不同try_lock 如果被调用时没有获得锁则直接返回 false如果在此期间其他线程释放了锁则该线程可以获得对互斥量的锁如果超时即在指定时间内还是没有获得锁则返回 false try_lock_until() 接受一个时间点作为参数在指定时间点未到来之前线程如果没有获得锁则被阻塞住 如果在此期间其他线程释放了锁则该线程可以获得对互斥量的锁如果超时即在指定时间内还是没有获得锁则返回 false
2.lock_guard
std::lock_gurad 是 C11 中定义的模板类。定义如下
templateclass _Mutex
class lock_guard
{public:// 在构造lock_gard时_Mtx还没有被上锁explicit lock_guard(_Mutex _Mtx): _MyMutex(_Mtx){_MyMutex.lock();}// 在构造lock_gard时_Mtx已经被上锁此处不需要再上锁lock_guard(_Mutex _Mtx, adopt_lock_t): _MyMutex(_Mtx){}~lock_guard() _NOEXCEPT{_MyMutex.unlock();}lock_guard(const lock_guard) delete;lock_guard operator(const lock_guard) delete;private:_Mutex _MyMutex;
}; 通过上述代码可以看到lock_guard类模板主要是通过RAII的方式对其管理的互斥量进行了封装在需要加锁的地方只需要用上述介绍的任意互斥体实例化一个lock_guard调用构造函数 成功上锁出作用域前lock_guard对象要被销毁调用析构函数自动解锁可以有效避免死锁 问题
lock_guard的缺陷太单一用户没有办法对该锁进行控制因此C11又提供了 unique_lock
3.unique_lock 与lock_gard类似unique_lock类模板也是采用RAII的方式对锁进行了封装并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作即其对象之间不能发生拷贝。在构造(或移动 (move)赋值)时unique_lock 对象需要传递一个 Mutex 对象作为它的参数新创建的 unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化 unique_lock的对象时自动调用构造函数上锁unique_lock对象销毁时自动调用析构函数解 锁可以很方便的防止死锁问题
与lock_guard不同的是unique_lock更加的灵活提供了更多的成员函数
上锁/解锁操作lock、try_lock、try_lock_for、try_lock_until和unlock修改操作移动赋值、交换(swap与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release返回它所管理的互斥量对象的指针并释放所有权)获取属性owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相 同)、mutex(返回当前unique_lock所管理的互斥量的指针)
5.支持两个线程交替打印一个打印奇数一个打印偶数
#include thread
#include mutex
#include condition_variablevoid two_thread_print()
{std::mutex mtx;condition_variable c;int n 100;bool flag true;thread t1([](){int i 0;while (i n){unique_lockmutex lock(mtx);c.wait(lock, []()-bool{return flag; });cout i endl;flag false;i 2; // 偶数c.notify_one();}});thread t2([](){int j 1;while (j n){unique_lockmutex lock(mtx);c.wait(lock, []()-bool{return !flag; });cout j endl;j 2; // 奇数flag true;c.notify_one();}});t1.join();t2.join();
}int main()
{two_thread_print();return 0;
}
