【C++】C++11

谁践踏了优雅 2024-03-17 23:07 118阅读 0赞

#### 文章目录 ####

*  C++11
 *   *  1. 统一的列表初始化
     *   *  1.1 \{\}初始化
     *  2. 声明
     *   *  2.1 auto
         *  2.2 decltype
         *  2.3 nullptr
     *  3. 右值引用和移动语义
     *   *  3.1 左值引用和右值引用
         *  3.2 左值引用与右值引用比较
         *  3.3 右值引用使用的场景和意义
         *  3.4 完美转发
     *  4. 可变参数模板
     *  5. lambda表达式
     *   *  5.1 函数对象与lambda表达式
     *  6. 线程库
     *   *  6.1 thread类的简单介绍
         *  6.2 线程函数参数
     *  7. 包装器
     *  8.bind

## 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 左值引用与右值引用比较 ####

左值引用总结：

1.  左值引用只能引用左值，不能引用右值
2.  const左值引用既可以引用左值，也可以引用右值

右值引用总结：

1.  右值引用只能引用右值，不能引用左值
2.  右值引用可以引用move以后的左值

#### 3.3 右值引用使用的场景和意义 ####

左值引用的短板：

![image-20230709205301133][]

只能使用传值返回，传值返回会导致至少一次拷贝构造

移动构造本质是将参数右值的资源窃取过来，占为已有。那么就不用做深拷贝了，所以叫做移动构造。就是窃取别人的资源来构造自己

**不仅仅有移动构造，还有移动赋值**

![qsnpfu5bti-1688907511110.png][]

#### 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指针

![image-20230709213816350][]

#### 5.1 函数对象与lambda表达式 ####

函数对象又称为仿函数，是可以像函数一样使用的对象。就是在类中重载了operator()运算符的类对象

![al3cwq0fkd-1688910086295.png][]

### 6. 线程库 ###

#### 6.1 thread类的简单介绍 ####

在C++11之前，涉及到多线程的问题，都是和平台相关的。window和Linux都有自己的接口，这就让代码的移植性比较差。**C++11当中最重要的特性就是对线程进行了支持，使C++在编程时不需要依赖第三方库**

注意：

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

[image-20230709205301133]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/373cfdf384cd4fbaa28f9b995b7fb4cb.png
[qsnpfu5bti-1688907511110.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f87241663c504e50bc44343d64aea7b6.png
[image-20230709213816350]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/639c31eb19114eefa5ee886d792fc1c9.png
[al3cwq0fkd-1688910086295.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f229a72b703845049bec62eb757116b0.png