文章目录
C++11
1. 统一的列表初始化
1.1 {}初始化
C++11扩大了用大括号括起来的列表的使用范围。使其适用于所有的内置类型和用户自定义的类型。使用初始化列表时,可以添加等号(=),也可以不添加
2. 声明
2.1 auto
C++11当中将其用于实现自动类型推断,这样要求必须进行显示初始化,让编译器将定义对象的类型设置为初始化值的类型。
2.2 decltype
将变量的类型声明为表达式指定的类型
2.3 nullptr
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
3. 右值引用和移动语义
3.1 左值引用和右值引用
传统的C++语法当中就有引用的概念,C++11当中增加了右值引用语法特性。无论是左值引用还是右值引用都是给变量起别名
什么是左值?什么是右值?
左值表示一个数据的表达式(如变量名或者解引用的指针),我们可以获取它的地址+可以对它赋值。左值可以出现在赋值符号的左边,右值不能出现在赋值符号的左边
int main() {
// 以下都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 一下都是左值的引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& value = *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;
}
需要注意的是右值是不能取地址的,但是给右值取别名之后,会导致右值存储到特别的位置,并且可以取到该位置的地址。
int main() {
double x = 1.1, y = 2.2;
int&& rr1 = 10;
const double&& rr2 = x + y;
rr1 = 20;
rr2 = 5.5; // 报错
return 0;
}
3.2 左值引用与右值引用比较
左值引用总结:
- 左值引用只能引用左值,不能引用右值
- const左值引用既可以引用左值,也可以引用右值
右值引用总结:
- 右值引用只能引用右值,不能引用左值
- 右值引用可以引用move以后的左值
3.3 右值引用使用的场景和意义
左值引用的短板:
只能使用传值返回,传值返回会导致至少一次拷贝构造
移动构造本质是将参数右值的资源窃取过来,占为已有。那么就不用做深拷贝了,所以叫做移动构造。就是窃取别人的资源来构造自己
不仅仅有移动构造,还有移动赋值
3.4 完美转发
模板当中的&& 不代表右值引用。而是万能引用。既能接收左值又能接收右值。模板的万能引用只是提供了同时接收左值引用又能接收右值引用。但是引用类型的唯一作用就是限制了接收的类型,后续引用中都退化成为了左值。如果在传递的过程当中保持左值或右值的属性,就需要这个完美转发了
forward
保证了传参过程中的原生类型属性
强制生成默认函数的关键字default
比如我们提供了拷贝构造,就不会生成移动构造了,我们可以使用default
关键字显示指定移动构造生成
禁止生成默认构造函数的关键字delete
4. 可变参数模板
template<class...Args>
void show(Args...args) {
}
递归方式展开参数包:
// 递归终止函数
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;
}
5. lambda表达式
lambda表达式实际上是一个匿名函数
lambda表达式的书写格式:
[capture-list] (parameters) mutable->return-type{statement}
int main() {
int a = 3, b = 4;
[=]{
return a + b;};
auto fun1 = [&](int c){
b = a + c;
};
fun1(10);
cout << b << " " << a << endl;
// 复制捕捉x
int x = 20;
auto add_x = [x](int a) mutable {
x *= 2;
return a + x;
};
cout << add_x(10) << endl;
cout << typeid(a).name() << endl;
cout << typeid(add_x(10)).name() << endl;
}
- [var]表示值传递方式,捕捉变量var
- [=]:表示值传递方式,捕捉所有父作用域中的变量
- [&var]:表示引用传递捕捉变量var
- [&] : 表示引用传递所有父作用域中的变量
- [this]:表示值传递方式捕捉当前的this指针
5.1 函数对象与lambda表达式
函数对象又称为仿函数,是可以像函数一样使用的对象。就是在类中重载了operator()运算符的类对象
6. 线程库
6.1 thread类的简单介绍
在C++11之前,涉及到多线程的问题,都是和平台相关的。window和Linux都有自己的接口,这就让代码的移植性比较差。C++11当中最重要的特性就是对线程进行了支持,使C++在编程时不需要依赖第三方库
注意:
-
线程是操作系统中的概念,线程对象可以关联一个线程,用来控制线程以及获取线程的状态
-
当创建一个线程时, 没有提供线程函数,该对象实际没有对应任何线程
-
当创建一个线程对象后,并且线程关联线程函数,这个线程就被启动。与主线程一起运行。线程函数一般按照如下三种方式提供:
- 函数指针
- lambda表达式
- 函数对象
6.2 线程函数参数
线程函数参数是以值拷贝的方式拷贝到线程栈空间当中。因此即使线程参数为引用类型,在线程当中修改之后也还是不能修改外部实参。因为实际引用的是线程栈中的拷贝,不是外部实参
两个线程交替打印奇书偶数
#include "iostream"
#include "condition_variable"
#include "mutex"
#include "thread"
using namespace std;
//支持两个线程交替打印,t1打印奇数,t2一个打印偶数
int main(){
mutex mtx;
condition_variable cv;
int n = 100;
int x = 1;
// 问题1:如何保证t1先运行,t2阻塞?
// 问题2:如何防止一个线程不断运行?
thread t1([&, n]() {
while (true){
unique_lock<mutex> lock(mtx);
if (x >= 100)
break;
if (x % 2 == 0) // 偶数就阻塞
{
cv.wait(lock);
}
// cv.wait(lock, [&x]() {return x % 2 != 0; });
cout << this_thread::get_id() << ":" << x << endl;
++x;
cv.notify_one();
}
});
thread t2([&, n]() {
while (true){
unique_lock<mutex> lock(mtx);
if (x > 100)
break;
if (x % 2 != 0) // 奇数就阻塞
{
cv.wait(lock);
}
// cv.wait(lock, [&x](){return x % 2 == 0; });
cout << this_thread::get_id() << ":" << x << endl;
++x;
cv.notify_one();
}
});
t1.join();
t2.join();
return 0;
}
7. 包装器
function包装器
也叫适配器,我们来看看为什么需要包装器?本质上是一个类模板,也是一个包装器。
包装器的一个使用例子:
使用包装器之前的:
class Solution {
public:
static int evalRPN(vector <string> &tokes)
{
stack<int> s;
for (auto&str : tokes)
{
if (str == "+" || str == "-" || str == "*" || str == "/")
{
int right = s.top();
s.pop();
int left = s.top();
s.pop();
switch(str[0])
{
case '+':
s.push(left + right);
break;
case '-':
s.push(left - right);
break;
case '*':
s.push(left * right);
break;
case '/':
s.push(left / right);
break;
default:
break;
}
}
else
{
s.push(stoi(str));
}
}
}
};
使用包装器之后:
class Solution {
public:
static int evalRPN(vector <string> &tokes)
{
stack<int> st;
map<string, function<int(int, int)>> opFuncMap ={
{
"+", [](int i, int j){
return i + j;}},
{
"-", [](int i, int j){
return i - j;}},
{
"*", [](int i, int j){
return i * j;}},
{
"/", [](int i, int j){
return i / j;}}
};
for (auto& str : tokes)
{
if (opFuncMap.find(str) != opFuncMap.end())
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
st.push(opFuncMap[str](left, right));
}
}
}
};
8.bind
bind函数定义在头文件当中,是一个函数模板,它就像一个函数包装器(适配器)接收一个可调用对象生成一个新的可调用对象来“适应”原对象的参数列表。
一般而言,我么可以原本接收N个函数的参数的函数fn,通过绑定一些参数,返回一个接收M个参数(M可以大于N)
调用bind的一般形式是:auto newCallable = bind(callable, arg_list)
//表示绑定函数plus 参数分别由调用 func1 的第一,二个参数指定
std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,placeholders::_2);