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++在编程时不需要依赖第三方库

注意：

线程是操作系统中的概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态
当创建一个线程时，没有提供线程函数，该对象实际没有对应任何线程
当创建一个线程对象后，并且线程关联线程函数，这个线程就被启动。与主线程一起运行。线程函数一般按照如下三种方式提供：
1. 函数指针
2. lambda表达式
3. 函数对象

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);

【C++】C++11

文章目录