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取别名
要求
- 有关相互引用:
- 二者不能直接互相引用
- const locator value可以引用 read value
- 右值引用可以引用 move (locator value)
- 右值引用变量, 会被看做一个左值
举例
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左值 引用临时对象比较
- 右值引用: std::string&& r3 = s1 + s1;
const std::string& r2 = s1 + s1;也能够像右值引用一样延长临时对象生命周期
前者可以修改,后者不能修改‼️
实际调用看一下
强调:
- 右值引用变量, 会被看做一个左值

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使用场景
-
之前的左值引用有拷贝问题:
- 比如函数返回string 这种对象时, 不能返回左值引用, 因为函数结束后 对象 就销毁了。
- 只能传值返回, 但深拷贝很花时间
-
移动语义:
-
新写一种构造, 来避免拷贝------>叫做移动构造: 直接把原来的那块内存交给新对象, 就相当于是用了个swap:
string(string&& s) {swap(s); // 交换双方管理的资源} -
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)); ///////////////////////////////////////
}
