[C++] C++11

C++11

### 文章目录

  • [C++11](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [@toc](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [1.{ }](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [2.initializer_list](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [2.1是什么](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.右值引用 and 移动语义](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.1左值和右值](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.2左值引用 and 右值引用](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [是什么](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [要求](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [举例](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [1.左值引用](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [2.右值引用](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.const左值 引用右值](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [右值引用和const左值 引用临时对象比较](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [实际调用看一下](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.3使用场景](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.4引用折叠](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [四种情况:](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [示例 (万能引用)](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [3.5完美转发](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [问题代码:](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)
  • [完美转发](#文章目录 C++11 @[toc] 1.{ } 2.initializer_list 2.1是什么 3.右值引用 and 移动语义 3.1左值和右值 3.2左值引用 and 右值引用 是什么 要求 举例 1.左值引用 2.右值引用 3.const左值 引用右值 右值引用和const左值 引用临时对象比较 实际调用看一下 3.3使用场景 3.4引用折叠 四种情况: 示例 (万能引用) 3.5完美转发 问题代码: 完美转发)


1.{ }

  • 列表初始化: 一切对象都可以用{}初始化
    • 自定义类型也支持, 本质是类型转换, 中间产生临时变量, 但在优化后变成了直接构造
    • 可以不写等号= : Point p1 { 1, 2 }; int x{6}
cpp 复制代码
#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
using namespace std;

struct Point
{
    int _x;
    int _y;
};

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
    {
        cout << "Date(int year, int month, int day)" << endl;
    }

    Date(const Date& d)
        :_year(d._year)
        , _month(d._month)
        , _day(d._day)
    {
        cout << "Date(const Date& d)" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};






int main()
{
    // C++98支持的
    int a1[] = { 1, 2, 3, 4, 5 };
    int a2[5] = { 0 };
    Point p = { 1, 2 };
     
    int x1 = { 2 }; 



    Date d1 = { 2025, 1, 1 };


    const Date& d2 = { 2024, 7, 25 };

 
    Date d3 = { 2025 };///相当于:Date(2025, 1, 1);
    Date d4 = 2025;

    // 可以省略掉=
    Point p1{ 1, 2 };
    int x2{ 2 };
    Date d6{ 2024, 7, 25 };
    const Date& d7{ 2024, 7, 25 }; ///先调用构造函数创建一个临时 `Date` 对象(右值),再通过 `const Date& ` 这个** 常量左值引用绑定右值** ,并延长临时对象的生命周期。
     
    vector<Date> v;
    v.push_back(d1);
    v.push_back(Date(2025, 1, 1));

    // 比起有名对象和匿名对象传参, 这里{}更有性价比
    v.push_back({ 2025, 1, 1 });

    return 0;
}





2.initializer_list

C++11 之前, 不支持这种写法。

复制代码
vector<int> v = {1, 2, 3, 4, 5};  // C++11 才支持

C++98 要这样写:

复制代码
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);

C++11 引入 initializer_list , 让 vector 等 STL 容器也能直接用 {} 初始化。

2.1是什么

  • 一种新的类
  • 本质是底层开一个数组, 然后会把数据拷贝过来, std::initializer_list 内部有2个指针分别指向数组的开始和结束










3.右值引用 and 移动语义

3.1左值和右值

  • 左值(loactor value): 有明确存储位置、通常可以取地址的表达式(如变量 a: int a=666;)。
  • 右值(read value): 临时产生的值,通常不能直接取地址(如 10、a + b)。



3.2左值引用 and 右值引用

是什么

  • 左值引用: int & x= y; ------>就是我们之前学的取别名
  • 右值引用: int && x = 100;------>给右边的100取别名

要求

  1. 有关相互引用:
    1. 二者不能直接互相引用
    2. const locator value可以引用 read value
    3. 右值引用可以引用 move (locator value)
  2. 右值引用变量, 会被看做一个左值

举例

1.左值引用
cpp 复制代码
    // 左值: 可以取地址
    // 以下的p、b、c、*p、s、s[0]就是常见的左值
    int* p = new int(0);
    int b = 1;
    const int c = b;
    *p = 10;
    string s("111111");
    s[0] = 'x';
    double x = 1.1, y = 2.2;

    // 左值引用给左值取别名
    int& r1 = b;
    int& r2 = p;
    int& r3 = *p;
    string& r4 = s;
    char& r5 = s[0];



2.右值引用
cpp 复制代码
    // 右值引用给右值取别名
    int&& rr1 = 10;
    double&& rr2 = x + y;  // 都不能直接相互引用,但是有办法:
    double&& rr3 = fmin(x, y); // const 左可以引用 read value
    string&& rr4 = string("11111"); // read value 可以引用 move(locator value)



3.const左值 引用右值
cpp 复制代码
    // 左值引用不能直接引用右值,但是const左值引用可以引用右值
    const int& rx1 = 10;
    const double& rx2 = x + y;
    const double& rx3 = fmin(x, y);
    const string& rx4 = string("11111");

    // b、r1、rr1都是变量表达式,都是左值
    cout << &b << endl;
    cout << &r1 << endl;
    cout << &rr1 << endl;

    // 这里要注意的是,rr1的属性是左值,所以不能再被右值引用绑定,除非move一下
    int& r6 = r1;
    // int&& rrx6 = rr1;
    int&& rrx6 = move(rr1);

    return 0;
}



4.右值引用可以引用move(左值)

cpp 复制代码
    // 右值引用不能直接引用左值,但是右值引用可以引用move(左值)
    int&& rrx1 = move(b);
    int*&& rrx2 = move(p);
    int&& rrx3 = move(*p);
    string&& rrx4 = move(s);
    string&& rrx5 = (string&&)s;





右值引用和const左值 引用临时对象比较

  1. 右值引用: std::string&& r3 = s1 + s1;
  2. const std::string& r2 = s1 + s1;也能够像右值引用一样延长临时对象生命周期

前者可以修改,后者不能修改‼️




实际调用看一下

强调:

  1. 右值引用变量, 会被看做一个左值
cpp 复制代码
#include<iostream>
using namespace std;

void f(int& x)
{
    std::cout << "左值引用重载 f(" << x << ")\n";
}

void f(const int& x)
{
    std::cout << "到 const 的左值引用重载 f(" << x << ")\n";
}

void f(int&& x)
{
    std::cout << "右值引用重载 f(" << x << ")\n";
}

int main()
{
    int i = 1;
    const int ci = 2;

    f(i); // 调用 f(int&)
    f(ci); // 调用 f(const int&)
    f(3); // 调用 f(int&&),如果没有 f(int&&) 重载则会调用 f(const int&)
    f(std::move(i)); // 调用 f(int&&)

    // 右值引用变量在用于表达式时是左值
    int && x = 1; // 右值引用 调的是 左值引用 ← 右值引用本身的属性是左值
    f(x); // 调用 f(int& x)
    f(std::move(x)); // 调用 f(int& x)

    return 0;
}





3.3使用场景

  1. 之前的左值引用有拷贝问题:

    • 比如函数返回string 这种对象时, 不能返回左值引用, 因为函数结束后 对象 就销毁了。
    • 只能传值返回, 但深拷贝很花时间
  2. 移动语义:

    1. 新写一种构造, 来避免拷贝------>叫做移动构造: 直接把原来的那块内存交给新对象, 就相当于是用了个swap:

      string(string&& s) {swap(s); // 交换双方管理的资源}

    2. vector 也可以 新实现一种函数来避免拷贝------>

      void push_back(const T& x); // 接收左值,拷贝

      void push_back(T&& x); // 接收右值,移动






3.4引用折叠

四种情况:

  • 一个&代表左值引用
  • 两个&代表右值引用
原来的组合 最终结果
& & &
& && &
&& & &
&& && &&

只要出现一个 &,最终就是 &;只有两个 &&,最终才是 &&。




示例 (万能引用)

cpp 复制代码
template<class T>
void f2(T&& x)
{
}

int a = 10;

f2(a);   // a 是左值,T 推导为 int&,最终参数变成 int& &&,折叠为 int&
f2(10);  // 10 是右值, T 推导为 int,最终参数就是 int&&
cpp 复制代码
 
template<class T>
void f1(T& x)
{}
 
template<class T>
void f2(T&& x)
{}



int main()
{
   typedef int& lref;
   typedef int&& rref;
   int n = 0;
   lref& r1 = n;  // r1 的类型是 int&
   lref&& r2 = n; // r2 的类型是 int&
   rref& r3 = n;  // r3 的类型是 int&
   rref&& r4 = 1; // r4 的类型是 int&&
   // 没有折叠->实例化为void f1(int& x)
   f1<int>(n);
   f1<int>(0);  // 报错
   // 折叠->实例化为void f1(int& x)
   f1<int&>(n);
   f1<int&>(0); // 报错
   // 折叠->实例化为void f1(int& x)
   f1<int&&>(n);
   f1<int&&>(0); // 报错
   // 折叠->实例化为void f1(const int& x)
   f1<const int&>(n);
   f1<const int&>(0);
   // 折叠->实例化为void f1(const int& x)
   f1<const int&&>(n);

   f1<const int&&>(0);
   // 没有折叠->实例化为void f2(int&& x)
   f2<int>(n);   // 报错
   f2<int>(0);
   // 折叠->实例化为void f2(int& x)
   f2<int&>(n);
   f2<int&>(0);  // 报错
   // 折叠->实例化为void f2(int&& x)
   f2<int&&>(n); // 报错
   f2<int&&>(0);
   return 0;
} 





3.5完美转发

这个知识点是为了解决前面的一个问题:右值引用变量, 会被看做一个左值------>那我需要这个值就被看成是右值该怎么办?

问题代码:

cpp 复制代码
void Fun(int& x)  { cout << "左值引用"; }
void Fun(int&& x) { cout << "右值引用"; }

template<class T>
void Function(T&& t)
{
    Fun(t);
}


调用:
int a = 10;

Function(a);   // a 是左值
Function(10);  // 10 是右值

**两个都会调用左值引用版本!**⬅️右值引用变量, 会被看做一个左值




完美转发

cpp 复制代码
void Fun(int& x)  { cout << "左值引用"; }
void Fun(int&& x) { cout << "右值引用"; }

template<class T>
void Function(T&& t)
{
    Fun(std::forward<T>(t));  ///////////////////////////////////////
}
相关推荐
一条破秋裤2 小时前
【1117】【内存资源管控】【笔记】
android·笔记
Evand J2 小时前
【MATLAB例程】基于IMM-CKF的AOA+测距融合的二维移动目标跟踪定位
开发语言·matlab·目标跟踪
JianZhen✓3 小时前
IM 聊天列表为什么总“消息乱跳“:有序插入、时间轴派生、本地截断、已读回执
开发语言·前端·php
FungLeo3 小时前
FengCMS · PHP+MySQL 升级实录· 代码审计怎么闭环:REVIEW到 CLOSURE 四件套,12 个域90 篇修复文档跟到底
开发语言·mysql·php·代码审计·fengcms
七夜zippoe3 小时前
多轮对话管理:Session/记忆在 Java 后端怎么存(存储设计实战)
java·开发语言·ai·session·记忆
小小bugbug4 小时前
带工作窃取的线程池
c++·线程池
qingwufeiyang_5304 小时前
Docker学习笔记2
笔记·学习
屿华AI4 小时前
AUTOSAR 实战-诊断工具 | 基于 Python 与 USB-CANFD 的 UDS 诊断测试工具设计与实现
开发语言·python·测试工具
SomeOtherTime4 小时前
番外篇(第 12 讲):走向工业界深水区——从物理定律看 Rust 在真实工程中的“降维打击”与“阿喀琉斯之踵”
开发语言·rust