网站解析时候让做别名,襄阳建设路21号创意园网站,wordpress 公司展示,评估网站建设方案C11 新特性 C11 新特性统一的列表初始化声明auto 关键字decltype 关键字nullptr 关键字 关键字 using使用 using 在子类中引用基类的成员使用 using 关键字定义类型别名 范围-based for 循环右值引用和移动语义左值引用和右值引用右值引用使用场景和意义完美转发 lambda表达式移… C11 新特性 C11 新特性统一的列表初始化声明auto 关键字decltype 关键字nullptr 关键字 关键字 using使用 using 在子类中引用基类的成员使用 using 关键字定义类型别名 范围-based for 循环右值引用和移动语义左值引用和右值引用右值引用使用场景和意义完美转发 lambda表达式移动构造和移动赋值关键字 default 和 delete关键字 default强制生成默认函数关键字 delete禁止生成默认函数 可变参数模板包装器线程库线程函数参数原子性操作库mutex 的种类std::mutexstd::recursive_mutexstd::timed_mutexstd::recursive_timed_mutex lock_guradunique_lock实例互斥锁加条件变量实现交替打印数据 总结 C11 新特性
C从诞生到现在一直是一门主流的编程语言期间经历了多次更行迭代最近的一次大版本更新就是C11而现在大部分公司也把C11作为主流的应用版本。
相比于 C98/03C11则带来了数量可观的变化其中包含了约140个新特性以及对C03标准中 约600个缺陷的修正这使得C11更像是从C98/03中孕育出的一种新语言。
相比较而言 C11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全不仅功能更强大而且能提升程序员的开发效率。
统一的列表初始化
在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扩大了用大括号括起的列表初始化列表的使用范围使其可用于所有的内置类型和用户自定义的类型。
创建对象时也可以使用列表初始化方式调用构造函数初始化。C11中列表初始化也可以适用于new表达式中。
使用初始化列表时可添加等号也可不添加例如
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; }为什么这么多的容器或者类型都支持列表初始化呢是通过什么方式让内置、自定义类型和容器都支持列表初始化呢
C11中新增了一个类型叫做initializer_list严格来说initializer_list在C里面是一个容器是原生支持的一个容器只要是{}都会被编译器自动识别成这个类型。 在C11中这些容器的构造函数中都支持了用initializer_list类型的构造函数下面这是一部分基本上所有的STL容器都支持了列表初始化。 除此之外initializer_list也可以作为operator的参数这样就可以用大括号赋值。
详细资料std::initializer_list
声明
C11提供了多种简化声明的方式尤其是在使用模板时。
auto 关键字
在C98中auto是一个存储类型的说明符表明变量是局部自动存储类型但是局部域中定义局部的变量默认就是自动存储类型所以auto就没什么价值了。
C11中废弃auto原来的用法将其用于实现自动类型推导Type Inference。使用auto声明变量时编译器会根据右边表达式的类型自动推断出变量的类型并将其类型推导为所初始化的表达式的类型。
auto i 10; // 推导为 int 类型
auto d 2.3; // 推导为 double 类型
auto s hello; // 推导为 const char* 类型C风格字符串需要注意的是auto声明的变量必须要进行初始化否则无法推导出变量的类型编译会报错。
auto还可以与特定修饰符一起使用如const、和*等。例如
const auto *p x; // 推导为const int*
auto a x; // 推导为int
auto b x; // 推导为int*因此通过结合auto和各种修饰符可以方便地定义各种类型的变量从而简化代码并提高程序的可读性和可维护性。
decltype 关键字
C11标准中新增了一个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(y) p; // p的类型是int* cout typeid(ret).name() endl; cout typeid(p).name() endl; F(1, a);return 0;
}看到这里大多数人都会认为decltype和auto是一样的但是对于以下场景只有decltype能做到。
例如decltype推导的类型可以作为容量里面的参数。
int main()
{mapstring, string m { { insert, 插入 }, { sort, 排序 } };auto it m.begin();// vectorauto it v; // 错误vectordecltype(it) v; // 正确return 0;
}nullptr 关键字
由于C中NULL一个宏被定义成字面量0这样就可能回带来一些问题因为0既能指针常量又能表示整形常量。
#ifndef NULL#ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif
#endif从源码中可以知道在C中NULL是((void *)0)指针在C中NULL却是个整数0。
所以出于清晰和安全的角度考虑C11中新增了nullptr用于表示空指针。
先来看一段代码
void func(char*)
{cout char*;
}
void func(int)
{cout int;
}int main()
{func(NULL); // 编译失败 error: call of overloaded ‘func(NULL)’ is ambiguousfunc(nullptr); // char*return 0;
}在C 的函数重载中传入NULL会导致编译失败所以需要引入nullptr使用nullptr可以解决函数重载中的参数匹配问题。
这里可以总结三点
使用nullptr可以不用担心整型和指针类型的重载不会产生二义性导致编译失败。0和空指针分别表示不同的含义使用nullptr可以更好的支持模板编程。使用nullptr使代码更安全让用户编写代码更清晰直观。
详细资料关于nullptr这篇文章你一定要看
关键字 using
在最开始学习C的时候using最广为人知的用法肯定是作为命名空间的使用例如using namespace std它在C11中又引入了两种最新的用法
在子类中引用基类的成员定义别名
我们都知道私有继承会继承父类public和protected部分为子类的private成员这意味着无法使用子类对象直接调用父类成员。
但是使用using可以访问
class father {
public:father() :value(55) {}virtual ~father() {}void test1() { cout father test1... endl; }
protected:int value;
};class son : private father {
public:using father::test1;using father::value;void test2() { cout value is value endl; }
};int main(int argv, char* argc[])
{son son;son.test1();son.test2();
}使用 using 在子类中引用基类的成员
大家都知道在 C 中可以通过 typedef 重定义一个类型
typedef unsigned int uint_t;但是面对以下例子是不是就会感觉开始比较难看了我们实际上就是想定义一个函数指针而已。
typedef void (*Fun) (int, const std::string);如果使用using的话这样看起来是不是就比较直接了
using Fun void (*) (int, const std::string);使用using定义别名看起来和typedef用法差不多但实际上typede无法重定义模板。
例如现在有模板
templatetypename T
typedef mapstd::string, T mapT;我们想这样定义
typedef mapstd::string, T mapT;实际就想定义一个key为string类型但是value类型不确定的模板但是这是错误的因为此时T对于typedef是不确定的类型如果真的想强行使用的话就需要写成这样
template typename T
struct str_map
{typedef std::mapstd::string, T mapT;
};
str_mapint::mapT map;但是如果使用using的话就可以很容易对模板进行重定义
templatetypename T
using mapT mapstd::string, T;使用 using 关键字定义类型别名
范围-based for 循环
给出一个容器如果想要遍历其中的数据需要用迭代器进行遍历例如
int main()
{vectorchar v { h, e, l, l, o };for (vectorchar::iterator it v.begin(); it ! v.end(); it){cout *(it) ;}cout endl;
}C11中推出了范围for可以简化上述代码
int main()
{vectorchar v { h, e, l, l, o };for (auto it : v){cout it ;}cout endl;
}其实for的底层原理还是用使用到了迭代器跟第一种遍历毫无差别只是换了种写法使代码看起来更简洁。
右值引用和移动语义
传统的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 去引用。 左值引用和右值引用的总结
左值引用只能引用左值不能引用右值。但是const左值引用既可引用左值也可引用右值。右值引用只能右值不能直接引用左值。但是右值引用可以引用move以后的左值也可以通过模板来间接引用左值。
示例
int main()
{// 以下的p、b、c、*p都是左值int* p new int(0);int b 1;const int c 2;//引用前必须加上const 否则会报错const int r 10;const double r1 x y;const double r2 fmin(x, y);//右值引用引用左值int* rr1 move(p);int rr2 move(*p);int rr3 move(b);const int rr4 move(c);return 0;
}右值引用使用场景和意义
前面我们可以看到左值引用既可以引用左值和又可以引用右值那为什么C11还要提出右值引用呢
下面我们来看看左值引用的短板右值引用是如何补齐这个短板的。
首先我们先来看看这样一段代码
// 拷贝构造
string(const string s) :_str(nullptr)
{coutstring(const string s)--深拷贝endl;string tmp(s._str)swap(tmp);
}string operator(char ch)
{string tmp(*this);push_back(ch);return tmp;
}s str !当str调用operator()时会拷贝一份临时对象tmp当函数返回时又会将临时对象tmp进行拷贝然后将tmp进行销毁。
但是我们发现在返回时没有必要用tmp再构造一份对象然后又将tmp销毁这样大大耗费了资源。
有没有一种方法在你销毁的时候将你的资源进行转移
通过右值引用来完成移动构造就能很好地解决这个问题。
// 移动构造
string(string s) :_str(nullptr)
{this-swap(s);coutstring(string s)--移动拷贝endl;
}虽然添加了移动构造但问题又来了在return tmp时编译器如何知道去调用移动构造而不是拷贝构造呢
要搞清楚这个问题需要弄明白右值的类型。
C11将右值分为了两种
纯右值内置类型的字面量比如10 xy。将亡值move(自定义类型)函数返回值自定义类型表达式等等。比如临时对象tmp因为出了作用域它就将被销毁。
当返回tmp时编译器会认为它是右值中的将亡值就会实行最佳匹配原则去调用移动构造转移资源而不会调用拷贝构造提高了效率。
除了移动构造之外还有移动赋值也是用来解决资源浪费的问题
string operator(string s)
{cout string operator(string s) -- 移动赋值 endl;swap(s);return *this;
}C11中STL中的容器都是增加了移动构造和移动赋值以提高性能。
虽然移动赋值和移动构造大大提升了性能但是有时也是非常危险的例如以下场景 将s通过move转为右值后移动赋值给s1s的ptr竟然变为nullptr为什么会这样呢
其实原因很简单移动赋值的本质其实就是资源转移将s的资源转移到了s1所以s的ptr自然而然的变为nullptr。
所以在使用移动语义时需要这些细节否则可能会给程序带来严重的后果。
之前听说过一句话右值引用延长了对象的生命周期。这句话其实是不太对的因为右值引用匹配上移动构造或者移动赋值只是将资源从将亡值上转移到了非将亡值并没有延长将亡值的生命周期。
右值引用真正的意义是什么
右值引用的真正意义是移动语义资源的移动利用临时对象或者表达式的特性避免资源的重复分配或者拷贝从而提高程序的执行效率。
完美转发
模板中的不代表右值引用而是万能引用其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力但是引用类型的唯一作用就是限制了接收的类型后续使用中都退化成了左值。
我们希望能够在传递过程中保持它的左值或者右值的属性就需要用到完美转发。
先看以下一段代码
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(100); //右值int a;PerfectForward(a); // 左值PerfectForward(std::move(a)); // 右值const int b 8;PerfectForward(b); // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}输出结果 问题1PerfectForward里面是右值引用引用左值会不会报错
答案是不会因为通过模板可以引用折叠。
模板中的不代表右值引用而是万能引用。万能引用引用折叠既可以引用左值也可以引用右值。
问题2这段代码的本意是通过万能引用左值去调用左值引用右值去调用右值引用。但实际上无论是左值还是右值都调用了左值引用这是为什么呢
因为在对一个数据进行右值引用后也会变为左值。
左值和右值有一个本质的区别就是左值可以取地址右值是不能取地址的但是给右值取别名后会导致右值被存储到特定位置且可以取到该位置的地址。
第一次传入100的时候100是一个右值但是通过右值引用之后t就是一个有空间的左值了再调用Fun函数就会输出左值引用。这其实是一种属性丢失。
对此C11提供了完美转发forward来保证右值引用后的属性保持不变。
将
Fun(t);改成
Fun(std::forwardT(t))示例 lambda表达式
在C98中如果想要对一个数据集合中的元素进行排序可以使用std::sort方法。如果待排序元素为自定义类型需要用户定义排序时的比较规则。
示例
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()
{vectorGoods 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算法都要重新去写一个类如果每次比较的逻辑不一样还要去实现多个类特别是相同类的命名这些都给编程者带来了极大的不便。因此在C11语法中出现了lambda表达式。
lambda表达式语法格式[capture-list] (parameters) mutable - return-type { statement }
lambda表达式各部分说明
[capture-list] : 捕捉列表该列表总是出现在lambda函数的开始位置编译器根据[]来判断接下来的代码是否为lambda函数捕捉列表能够捕捉上下文中的变量供lambda函数使用。(parameters)参数列表。与普通函数的参数列表一致如果不需要参数传递则可以连同()一起省略。mutable默认情况下lambda函数总是一个const函数mutable可以取消其常量性。使用该修饰符时参数列表不可省略即使参数为空。-returntype返回值类型。用追踪返回类型形式声明函数的返回值类型没有返回值时此部分可省略。返回值类型明确情况下也可省略由编译器对返回类型进行推导。{statement}函数体。在该函数体内除了可以使用其参数外还可以使用所有捕获到的变量。
注意 在lambda函数定义中参数列表和返回值类型都是可选部分而捕捉列表和函数体可以为空。因此C11中最简单的lambda函数为[]{}该lambda函数不能做任何事情。
示例1实现两个数相加求和
int main()
{auto add [](int a, int b)-int{return a b; }; //[](int a, int b){return a b;};cout add(1, 2) endl;return 0;
}示例2实现对水果价格按照升序排序
int main()
{Goods gds[] { { 苹果, 2.1 }, { 香蕉, 3 }, { 橙子, 2.2 }, { 菠萝, 1.5 }, { 哈密瓜, 4 } };sort(gds, gds sizeof(gds) / sizeof(gds[0]), [](const Goods left, const Goods right)-bool{return left._price right._price; });//[](const Goods left, const Goods right){return left._price right._price;}for (auto item : gds){cout item._name : item._price endl;}return 0;
}例子3通过捕捉列表交换两个变量的值
int main()
{int a 10, b 20;auto swap [a, b]()mutable{int c a;a b;b c;};swap();cout a: a b: b endl;return 0;
}捕捉列表描述了上下文中那些数据可以被lambda使用以及使用的方式是传值还是传引用
[var]表示值传递方式捕捉变量var[]表示值传递方式捕获所有父作用域中的变量(成员函数中包括this)[var]表示引用传递捕捉变量var[]表示引用传递捕捉所有父作用域中的变量(成员函数中包括this)
注意
父作用域指包含lambda函数的语句块。语法上捕捉列表可由多个捕捉项组成并以逗号分割。比如[, a, b]以引用传递的方式捕捉变量a和b值传递方式捕捉其他所有变量 [a,this]值传递方式捕捉变量a和this引用方式捕捉其他变量。捕捉列表不允许变量重复传递否则就会导致编译错误。 比如[, a]已经以值传递方式捕捉了所有变量捕捉a重复。在块作用域以外的lambda函数捕捉列表必须为空。在块作用域中的lambda函数仅能捕捉父作用域中局部变量捕捉任何非此作用域或者非局部变量都会导致编译报错。lambda表达式之间不能相互赋值即使看起来类型相同。
总的来说lambda表达式就是一个仿函数底层被处理成为一个lambda_uuid的一个仿函数类。
移动构造和移动赋值
C类中有6个成员函数不写会被自动生成
构造函数析构函数拷贝构造函数拷贝赋值重载取地址重载const 取地址重载
C11 新增了两个移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下
如果你没有自己实现移动构造函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数对于内置类型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员变量是否实现移动构造如果实现了就调用移动构造没有实现就调用拷贝构造。如果你没有自己实现移动赋值重载函数且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数对于内置类型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员是否实现移动赋值如果实现了就调用移动赋值没有实现就调用拷贝赋值默认移动赋值跟上面移动构造完全类似。如果你提供了移动构造或者移动赋值编译器不会自动提供拷贝构造和拷贝赋值。
关键字 default 和 delete
关键字 default强制生成默认函数
C11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数但是因为一些原因这个函数没有默认生成。
比如我们提供了拷贝构造就不会生成默认的拷贝构造那么我们可以使用default关键字显示指定拷贝构造生成。
示例
class Person
{
public:Person() default;Person(const char* name, int age 0)//显示的写了构造函数编译器就不会生成默认的构造函数:_name(name), _age(age){}private:string _name;int _age;
};int main()
{Person s1(fl,10);//调用显示的拷贝构造Person s2;//调用default生成的默认拷贝构造return 0;
}关键字 delete禁止生成默认函数
如果能想要限制某些默认函数的生成在C98中是该函数设置成private这样只要其他人想要调用就会报错。
在C11中更简单只需在该函数声明加上delete即可该语法指示编译器不生成对应函数的默认版本称delete修饰的函数为删除函数。
示例
class Person
{
public:Person(){}Person(const Person p) delete;
private:string _name;int _age;
};int main()
{Person s2;Person s3 s2;//error C2280: “Person(const Person)”: 尝试引用已删除的函数return 0;
}可变参数模板
C98/03中类模版和函数模版中只能含固定数量的模版参数。
C11中新增了可变参数模板能够创建可以接受可变参数的函数模板和类模板。
下面就是一个基本可变参数的函数模板
// Args是一个模板参数包args是一个函数形参参数包
// 声明一个参数包Args...args这个参数包中可以包含0到任意个模板参数。
template class ...Args
void ShowList(Args... args)//获取参数包中参数的个数
{cout sizeof...(args) endl;//代表传进去的参数个数
}int main()
{ShowList();ShowList(1);ShowList(1, a);ShowList(12, sdf, 23.0);return 0;
}运行结果 参数args前面有省略号所以它就是一个可变模版参数我们把带省略号的参数称为“参数包”它里面包含了0到NN0个模版参数。我们无法直接获取参数包args中的每个参数的只能通过展开参数包的方式来获取参数包中的每个参数这是使用可变模版参数的一个主要特点也是最大的难点即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数所以我们可以通过以下方式来获取参数包的值。
方法1递归函数方式展开参数包
void ShowList()
{cout endl;
}
//新增一个模板参数和函数形参利用递归的思维解决。
template class T,class ...Args
void ShowList(const T val,Args... args)
{cout val ;ShowList(args...);//当参数包为0的时候调用对应的无参函数
}
int main()
{ShowList();ShowList(1);ShowList(1, a);ShowList(12, sdf, 23.0);return 0;
}运行结果 方法2逗号表达式展开参数包
template class T
void PrintArg(T val)
{cout val ;
}
//展开函数
//这种展开参数包的方式不需要通过递归终止函数是直接在expand函数体中展开的
//PrintArg不是一个递归终止函数只是一个处理参数包中每一个参数的函数。
//这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式
//expand函数中的逗号表达式(PrintArg(args), 0)也是按照这个执行顺序先执行PrintArg(args)再得到逗号表达式的结果0
template class ...Args
void ShowList(Args... args)
{int arr[] { (PrintArg(args), 0)... };//也可以写成int arr[] { PrintArg(args)... };cout endl;
}
int main()
{ShowList(1);ShowList(1, A);ShowList(1, A, string(fl));return 0;
}运行结果 包装器
function包装器也叫作适配器。
C中的function本质是一个类模板也是一个包装器。
示例
templateclass 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;// lambda表达式cout useF([](double d)-double{ return d / 4; }, 11.11) endl;return 0;
}运行结果 通过上面的程序验证我们会发现useF函数模板实例化了三份导致模板的效率低下。
包装器可以很好的解决上面的问题。
templateclass 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::functiondouble(double) func1 f;cout useF(func1, 11.11) endl;// 函数对象std::functiondouble(double) func2 Functor();cout useF(func2, 11.11) endl;// lambda表达式std::functiondouble(double) func3 [](double d)-double{ return d / 4; };cout useF(func3, 11.11) endl;return 0;
}运行结果 值得注意的是对成员函数进行包装时需要取地址。
bind是一个函数模板它就像一个函数包装器适配器接受一个可调用对象生成一个新的可调用对象来“适应”原对象的参数列表。一般而言我们用它可以把一个原本接收N个参数的函数fn通过绑定一些参数返回一个接收M个M可以大于N但这么做没什么意义参数的新函数。同时使用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为第二个参数以此类推。
示例
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::functionint(int, int) func1 std::bind(Plus, placeholders::_1, placeholders::_2);//auto func1 std::bind(Plus, placeholders::_1, placeholders::_2);//func2的类型为 functionvoid(int, int, int) 与func1类型一样//表示绑定函数plus,第一个参数为1第二个参数为2auto func2 std::bind(Plus, 1, 2);cout func1(1, 2) endl;//3cout func2() endl;//3//绑定成员函数Sub s;std::functionint(int, int) func3 std::bind(Sub::sub, s, placeholders::_1, placeholders::_2);// 参数调换顺序std::functionint(int, int) func4 std::bind(Sub::sub, s, placeholders::_2, placeholders::_1);cout func3(1, 2) endl;//-1cout func4(1, 2) endl;//1return 0;
}运行结果 线程库
C11中最重要的特性之一就是支持了线程使得C在并行编程时不需要依赖第三方库而且在原子操作中还引入了原子类的概念。
要使用标准库中的线程必须#includethread头文件。
详细资料std::thread
常用函数
函数名功能thread()构造一个线程对象没有关联任何线程函数即没有启动任何线程thread(fn,args1, args2,…)构造一个线程对象并关联线程函数fnargs1args2…为线程函数的线程get_id()获取线程idjoinable()线程是否还在执行joinable代表的是一个正在执行中的线程join()该函数调用后会阻塞住线程当该线程结束后主线程继续执行detach()在创建线程对象后马上调用用于把被创建线程与线程对象分离开分离的线程变为后台线程创建的线程的死活就与主线程无关
注意
线程是操作系统中的一个概念线程对象可以关联一个线程用来控制线程以及获取线程的状态。当创建一个线程对象后没有提供线程函数该对象实际没有对应任何线程。当创建一个线程对象后并且给线程关联线程函数该线程就被启动与主线程一起运行。线程函数一般情况下可按照三种方式提供函数指针、lambda表达式、函数对象。thread类是防拷贝的不允许拷贝构造以及赋值但是可以移动构造和移动赋值即将一个线程对象关联线程的状态转移给其他线程对象转移期间不意向线程的执行可以通过jionable()函数判断线程是否是有效的如果是以下任意情况则线程无效①采用无参构造函数构造的线程对象。②线程对象的状态已经转移给其他线程对象。③程已经调用jion或者detach结束。如果是类成员函数作为线程参数时必须将this作为线程函数参数。
线程函数参数
线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的因此即使线程参数为引用类型在线程中修改后也不能修改外部实参因为其实际引用的是线程栈中的拷贝而不是外部实参。
示例
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;//10没有改变a的值// 如果想要通过形参改变外部实参时必须借助std::ref()函数thread t2(ThreadFunc1, std::ref(a));t2.join();cout a endl;//20改变了a的值// 地址的拷贝thread t3(ThreadFunc2, a);t3.join();cout a endl;//30改变了a的值return 0;
}注意如果是类成员函数作为线程参数时必须将this作为线程函数参数。
原子性操作库
多线程最主要的问题是共享数据带来的问题即线程安全。
如果共享数据都是只读的那么没问题因为只读操作不会影响到数据更不会涉及对数据的修改所以所有线程都会获得同样的数据。但是当一个或多个线程要修改共享数据时就会产生很多潜在的麻烦。
示例
#include iostream
#include thread
using namespace std;
int main()
{int sum 0;cout Before joining, sum sum std::endl;thread t1([]{for (int i 0; i 100000; i){sum;}});thread t2([]{for (int i 0; i 100000; i){sum;}});t1.join();t2.join();cout After joining, sum sum std::endl;system(pause);return 0;
}运行结果 可以看出计算结果是错误的。
C98中传统的解决方式可以对共享修改的数据可以加锁保护。
#include iostream
#include thread
#include mutex
using namespace std;int main()
{int sum 0;mutex mtx;cout Before joining, sum sum std::endl;thread t1([]{for (int i 0; i 100000; i){//通过加锁来保证原子性mtx.lock();sum;mtx.unlock();} });thread t2([]{for (int i 0; i 100000; i){mtx.lock();sum;mtx.unlock();} });t1.join();t2.join();cout After joining, sum sum std::endl;system(pause);return 0;
}运行结果 虽然加锁可以解决但是加锁有一个缺陷就是只要一个线程在对sum时其他线程就会被阻塞会影响程序运行的效率而且锁如果控制不好还容易造成死锁。
因此C11中引入了原子操作即不可被中断的一个或一系列操作。C11引入的原子操作类型使得线程间数据的同步变得非常高效。
原子类型名称对应内置类型名称atomic_boolboolatomic_charcharatomic_scharsigned charatomic_ucharunsigend charatomic_intintatomic_uintunsigned intatomic_shortshortatomic_ushortunsigned shortatomic_longlongatomic_ulongunsigned longatomic_llonglong longatomic_ullongunsigned long longatomic_char16_tchar16_tatomic_char32_tchar32_tatomic_wchar_twchar_t
#include iostream
#include thread
#include atomic
using namespace std;
int main()
{atomic_intint sum 0;cout Before joining, sum sum std::endl;thread t1([]{for (int i 0; i 100000; i){sum;} });thread t2([]{for (int i 0; i 100000; i){sum;} });t1.join();t2.join();cout After joining, sum sum std::endl;system(pause);return 0;
}运行结果 在C11中程序员不需要对原子类型变量进行加锁解锁操作线程能够对原子类型变量互斥的访问。更为普遍的程序员可以使用atomic类模板定义出需要的任意原子类型。
注意原子类型通常属于“资源型”数据多个线程只能访问单个原子类型的拷贝因此在C11中原子类型只能从其模板参数中进行构造不允许原子类型进行拷贝构造、移动构造以及operator等为了防止意外标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。
示例
#include atomic
int main()
{atomicint a1(0);atomicint a2(a1); // 编译失败atomicint a2(0);a2 a1; // 编译失败return 0;
}mutex 的种类
std::mutex
C11提供的最基本的互斥量该类的对象之间不能拷贝也不能进行移动。mutex最常用的三个函数
函数名函数功能lock()上锁锁住互斥量unlock()解锁释放对互斥量的所有权try_lock()尝试锁住互斥量如果互斥量被其他线程占有则当前线程也不会被阻塞
注意线程函数调用lock()时可能会发生以下三种情况
如果该互斥量当前没有被锁住则调用线程将该互斥量锁住直到调用 unlock之前该线程一直拥有该锁。如果当前互斥量被其他线程锁住则当前的调用线程被阻塞住。如果当前互斥量被当前调用线程锁住则会产生死锁。
线程函数调用try_lock()时可能会发生以下三种情况
如果当前互斥量没有被其他线程占有则该线程锁住互斥量直到该线程调用 unlock释放互斥量。如果当前互斥量被其他线程锁住则当前调用线程返回 false而并不会被阻塞掉。如果当前互斥量被当前调用线程锁住则会产生死锁。
std::recursive_mutex
其允许同一个线程对互斥量多次上锁即递归上锁来获得对互斥量对象的多层所有权释放互斥量时需要调用与该锁层次深度相同次数的 unlock()除此之外std::recursive_mutex 的特性和 std::mutex 大致相同。
std::timed_mutex
比 std::mutex 多了两个成员函数 try_lock_for() 接受一个时间范围表示在这一段时间范围之内线程如果没有获得锁则被阻塞住与std::mutex 的 try_lock() 不同try_lock 如果被调用时没有获得锁则直接返回false如果在此期间其他线程释放了锁则该线程可以获得对互斥量的锁如果超时即在指定时间内还是没有获得锁则返回 false。 try_lock_until() 接受一个时间点作为参数在指定时间点未到来之前线程如果没有获得锁则被阻塞住如果在此期间其他线程释放了锁则该线程可以获得对互斥量的锁如果超时即在指定时间内还是没有获得锁则返回 false。
std::recursive_timed_mutex
带超时的递归互斥量主要结合了超时和递归。
lock_gurad
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。
unique_lock
与lock_gard类似unique_lock类模板也是采用RAII的方式对锁进行了封装并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作即其对象之间不能发生拷贝。
在构造或移动赋值时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所管理的互斥量的指针。
实例互斥锁加条件变量实现交替打印数据
代码
#include iostream
#include mutex
#include condition_variable
#include thread
using namespace std;// 用互斥锁和条件变量实现交替打印数据
int main()
{int n 100;int i 0;condition_variable cv;mutex mtx;bool flag false;// 打印奇数thread t1([]{while (i n){//加锁unique_lockmutex lock(mtx);//flag是false时会一直处于阻塞状态直到flag变为truecv.wait(lock, []{return !flag; });cout std::this_thread::get_id() - i endl;i;//防止该线程在自己的时间片内多次成功竞争锁多次打印flag true;//唤醒其他线程(一个)cv.notify_one();} });// 打印偶数thread t2([]{while (i n){unique_lockmutex lock(mtx);cv.wait(lock, []{return flag; });cout std::this_thread::get_id() - i endl;i;flag false;cv.notify_one();} });t1.join();t2.join();system(pause);return 0;
}运行结果 总结
C11是C语言的一个重要标准引入了许多新特性和改进。以下是C11中的一些主要新特性
自动类型推导Type Inference引入了 auto 关键字可以根据初始化表达式自动推导变量的类型。统一的初始化语法Uniform Initialization可以使用花括号 {} 初始化对象无论是基本类型、数组、类对象还是容器。右值引用Rvalue References引入了 符号允许绑定到临时对象右值支持移动语义和完美转发。移动语义Move Semantics通过右值引用和移动构造函数实现了资源的高效转移避免不必要的拷贝操作。lambda 表达式可以在代码中定义匿名函数简化函数对象的创建和使用。范围-based for 循环用于遍历容器中的元素提供了一种更简洁、安全的遍历方式。nullptr引入了 nullptr 关键字代表空指针替代了传统的 NULL 宏。强类型枚举Strongly Typed Enums枚举类型具有更强的类型检查和作用域可以指定底层数据类型。类型别名Type Aliases可以使用 using 关键字定义类型别名提高代码可读性和可维护性。线程支持库Thread Support Library引入了多线程编程的支持包括线程、互斥锁、条件变量等。标准库的增强包括智能指针、正则表达式库、新的容器类型如 unordered_map、array、 std::function 等。右值引用和模板完美转发通过 std::forward 实现模板函数参数的完美转发避免了额外的拷贝构造函数调用。
这只是C11中一些主要的新特性还有其他一些小的语法改进和标准库的增强。C11的引入为C语言增加了更多的表达能力和灵活性使得代码编写更加简洁、高效和安全。
