目录
2.3 C++11中的std::initializer_list
2. 列表初始化
2.1 C++98传统的{}
C++98中⼀般数组和结构体可以⽤{}进⾏初始化。
struct Point
{
int _x;
int _y;
};
int main()
{
// C++98中数组和结构体可以用{}初始化
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
return 0;
}
2.2 C++11中的{}
- C++11以后想统⼀初始化⽅式，试图实现⼀切对象皆可⽤{}初始化，{}初始化也叫做列表初始化。
- 内置类型⽀持，⾃定义类型也⽀持，⾃定义类型本质是类型转换，中间会产⽣临时对象，最后优化了以后变成直接构造。
- 自定义类型是构造加拷贝构造，由编译器自主优化成直接构造。若初始化过程直接匹配了目标类型的构造函数（如std::initializer_list构造函数或其他参数匹配的构造函数），则会直接调用构造函数，不存在临时对象和拷贝构造的过程。
- {}初始化的过程中，可以省略掉=
- C++11列表初始化的本意是想实现⼀个⼤统⼀的初始化⽅式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很⽅便
#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++11⽀持的
// 内置类型⽀持
int x1 = { 2 };
// ⾃定义类型⽀持
// 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象
// 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
// 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
Date d1 = { 2025, 1, 1 };
// 这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象
const Date& d2 = { 2024, 7, 25 };
// 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}
Date d3 = { 2025 };
// 单参数隐式类型转换，因为Date的构造函数的参数均有缺省值，所以可以算是单参数
Date d4 = 2025;
// 可以省略掉=
Point p1{ 1, 2 };
int x2{ 2 };
Date d6{ 2024, 7, 25 };
const Date& d7{ 2024, 7, 25 };
// 不⽀持，只有{}初始化，才能省略=
// Date d8 2025;
vector<Date> v;
v.push_back(d1);
v.push_back(Date(2025, 1, 1));// 匿名对象传参
// ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
v.push_back({ 2025, 1, 1 });
return 0;
}
2.3 C++11中的std::initializer_list
- 上⾯的初始化已经很⽅便，但是对象容器初始化还是不太⽅便，⽐如⼀个vector对象，我想⽤N个值去构造初始化，那么我们得实现很多个构造函数才能⽀持。
- C++11库中提出了⼀个std::initializer_list的类， auto il = { 10, 20, 30 }; // the type of il is an initializer_list ，这个类的本质是底层开⼀个数组，将数据拷⻉过来，std::initializer_list内部有两个指针分别指向数组的开始和结束。
vector(initializer_list<T> l) { for (auto e : l) push_back(e); }
- 这是他的⽂档：initializer_list，std::initializer_list⽀持迭代器遍历。
- 容器⽀持⼀个std::initializer_list的构造函数，也就⽀持任意多个值构成的 {x1,x2,x3...} 进⾏ 初始化。STL中的容器⽀持任意多个值构成的 {x1,x2,x3...} 进⾏初始化，就是通过 std::initializer_list的构造函数⽀持的。
// STL中的容器都增加了⼀个initializer_list的构造 vector (initializer_list<value_type> il, const allocator_type& alloc = allocator_type()); list (initializer_list<value_type> il, const allocator_type& alloc = allocator_type()); map (initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type()); // 另外，容器的赋值也⽀持initializer_list的版本 vector& operator= (initializer_list<value_type> il); map& operator= (initializer_list<value_type> il);
int main()
{
// 内部有两个指针，指向数组的开始和结束
// 大小就是两个指针的大小，64位下是8+8=16
std::initializer_list<int> mylist;
mylist = { 10, 20, 30 };
cout << sizeof(mylist) << endl;
// 这⾥begin和end返回的值initializer_list对象中存的两个指针
// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
int i = 0;
cout << mylist.begin() << endl;
cout << mylist.end() << endl;
cout << &i << endl;
// {}列表中可以有任意多个值
// 这两个写法语义上还是有差别的，第⼀个v1是直接构造，
// 第⼆个v2是构造临时对象+临时对象拷⻉v2，优化为直接构造
vector<int> v1({ 1,2,3,4,5 });
vector<int> v2 = { 1,2,3,4,5 };
// 构造临时对象，v3引用临时对象
const vector<int>& v3 = { 1,2,3,4,5 };
// initializer_list版本的赋值⽀持
v1 = { 10,20,30,40,50 };
// 这⾥是pair对象的{}初始化和map的initializer_list构造结合到⼀起⽤了
map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };
return 0;
}3. 右值引⽤和移动语义
C++98的C++语法中就有引⽤的语法，⽽C++11中新增了的右值引⽤语法特性，C++11之后我们之前学习的引⽤就叫做左值引⽤。⽆论左值引⽤还是右值引⽤，都是给对象取别名。
3.1 左值和右值
- 左值是⼀个表⽰数据的表达式(如变量名或解引⽤的指针)，⼀般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const 修饰符后的左值，不能给他赋值，但是可以取它的地址。
- 右值也是⼀个表⽰数据的表达式，要么是字⾯值常量、要么是表达式求值过程中创建的临时对象 等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
- 值得⼀提的是，左值的英⽂简写为lvalue，右值的英⽂简写为rvalue。传统认为它们分别是left value、right value 的缩写。现代C++中，lvalue 被解释为loactor value的缩写，可意为存储在内 存中、有明确存储地址可以取地址的对象，⽽ rvalue 被解释为 read value，指的是那些可以提供 数据值，但是不可以寻址，例如：临时变量，字⾯量常量，存储于寄存器中的变量等，也就是说左值和右值的核⼼区别就是能否取地址。
int main()
{
// 左值：可以取地址
// 以下的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';
cout << &c << endl;
// operator[]的返回值是char&，是引用，想打印地址需要转换成void*
// cout输出char*类型时，会将其当作字符串处理,直到遇到 '\0' 为止
cout << (void*)&s[0] << endl;
double x = 1.1, y = 2.2;
// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
10;
x + y;
fmin(x, y);
string("11111");// 匿名对象，生命周期只在当前行
// 右值：不能取地址
//cout << &10 << endl;
//cout << &(x+y) << endl;
//cout << &(fmin(x, y)) << endl;
//cout << &string("11111") << endl;
return 0;
}3.2 左值引⽤和右值引⽤
- 左值引⽤： Type& r1 = x;，左值引⽤就是给左值取别名。
- 右值引⽤：Type&& rr1 = y;，同样的道理，右值引⽤就是给右值取别名。
- 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值，因为右值是不能修改，const修饰的变量不能修改，这样子不存在权限放大的问题。
这一特性的典型用途是延长右值的生命周期，例如：
const string& s = string("hello"); // 临时对象的生命周期被延长至与s一致std::move()
- 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)，move的作用是强制转换为右值引用，move是库⾥⾯的⼀个函数模板，本质内部是进⾏强制类型转换。他还涉及⼀些引⽤折叠的知识，这个我们后⾯会细讲。
（int a=10; move(a)的结果是右值，但a依然是左值）template <class _Ty> remove_reference_t<_Ty>&& move(_Ty&& _Arg) { // forward _Arg as movable return static_cast<remove_reference_t<_Ty>&&>(_Arg); }注意：当右值引用绑定到std::move(左值)后，若用于移动构造或移动赋值，会触发资源转移/掠夺（而非拷贝）。
string s1 = "hello"; // 本质：string s2=(string&&)s1 string s2 = std::move(s1); // 移动构造：s2掠夺s1的内存，s1变为空字符串
- 需要注意的是变量表达式都是左值属性，也就意味着⼀个右值被右值引⽤绑定后，右值引⽤变量变量表达式的属性是左值
- 语法层⾯看，左值引⽤和右值引⽤都是取别名，不开空间。从汇编底层的⻆度看下⾯代码中r1和rr1 汇编层实现，底层都是⽤指针实现的，没什么区别。但底层汇编等实现和上层语法表达的意义有时是背离的，所以不要然到⼀起去理解，互相佐证，这样反⽽是陷⼊迷途。
int main()
{
// 左值：可以取地址
// 以下的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';
// 左值引⽤给左值取别名
int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
char& r5 = s[0];
double x = 1.1, y = 2.2;
// 右值引⽤给右值取别名
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
string&& rr4 = string("11111");
// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
// 因为不存在权限放大的问题
const int& rx1 = 10;
const double& rx2 = x + y;
const double& rx3 = fmin(x, y);
const string& rx4 = string("11111");
// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
int&& rrx1 = move(b);
int*&& rrx2 = move(p);
int&& rrx3 = move(*p);
string&& rrx4 = move(s);
string&& rrx5 = (string&&)s;
// b、r1、rr1都是变量表达式，都是左值
cout << &b << endl;
cout << &r1 << endl;
cout << &rr1 << endl;
int& r6 = r1;
// 右值引用rr1的属性是左值，所以不能再被右值引⽤绑定，除⾮move⼀下
// int&& rrx6 = rr1;
int&& rrx6 = move(rr1);
return 0;
}3.3 引⽤延⻓⽣命周期
右值引⽤可⽤于为临时对象延⻓⽣命周期。左值引用和右值引用都是起别名，const 的左值引⽤虽然也能延⻓临时对象⽣存期，但这些对象⽆法被修改。而右值引用能进行修改。
// const左值引用不可修改 const int& s1 = 10; // 右值引用可以修改 int&& s2 = 10; s2 = 11;const 左值引用的关键是 “只读绑定”，右值引用的关键是 “可修改的临时对象绑定”。
int main()
{
string s1 = "Test";
// 错误：不能绑定到左值
// string&& r1 = s1;
// OK： const 的左值引⽤的右值的生命周期与其绑定
const string& r2 = s1 + s1;
// 错误：const 的左值引⽤不能进行修改
// r2 += "Test";
// OK：右值引⽤的右值的生命周期与其绑定
string&& r3 = s1 + s1;
// OK：右值引⽤可以进行修改
r3 += "Test";
cout << r3 << '\n';
return 0;
}3.4 左值和右值的参数匹配
- C++98中，我们实现⼀个const左值引⽤作为参数的函数，那么实参传递左值和右值都可以匹配。
void process(const string& s) {} int main() { string s1("111"); process(s1); process("temporary"); }
- C++11以后，分别重载左值引⽤、const左值引⽤、右值引⽤作为形参的f函数，那么实参是左值会匹配左值引⽤，实参是const左值会匹配const 左值引⽤，实参是右值会匹配右值引⽤。
// 左值引⽤ void f(int& x) {} // const 的左值引⽤ void f(const int& x) {} // 右值引⽤ void f(int&& x) {} 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&&) return 0; }
- 右值引⽤变量在⽤于表达式时属性是左值，这个设计这⾥会感觉跟怪，下面右值引⽤的使⽤场景时，就能体会这样设计的价值了
// 右值引⽤变量在⽤于表达式时是左值 int&& x = 1; f(x); // 调⽤ f(int& x)，因为x的属性是左值 f(std::move(x)); // 调⽤ f(int&& x)
3.5 右值引⽤和移动语义的使⽤场景
3.5.1 左值引⽤主要使⽤场景回顾
左值引⽤主要使⽤场景是在函数中左值引⽤传参和左值引⽤传返回值时减少拷⻉，同时还可以修改实参和修改返回对象的价值。左值引⽤已经解决⼤多数场景的拷⻉效率问题，但是有些场景不能使⽤传 左值引⽤返回，如addStrings和generate函数，C++98中的解决⽅案只能是被迫使⽤输出型参数解 决。那么C++11以后这⾥可以使⽤右值引⽤做返回值解决吗？显然是不可能的，因为这⾥的本质是返回对象是⼀个局部对象，函数结束这个对象就析构销毁了，右值引⽤返回也⽆法概念对象已经析构销毁的事实。
例如：下面的str和vv都是局部对象。
class Solution {
public:
// 传值返回需要拷⻉
string addStrings(string num1, string num2) {
string str;
int end1 = num1.size() - 1, end2 = num2.size() - 1;
// 进位
int next = 0;
while (end1 >= 0 || end2 >= 0)
{
int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
int ret = val1 + val2 + next;
next = ret / 10;
ret = ret % 10;
str += ('0' + ret);
}
if (next == 1)
str += '1';
reverse(str.begin(), str.end());
return str;
}
};
class Solution {
public:
// 这⾥的传值返回拷⻉代价就太⼤了
vector<vector<int>> generate(int numRows) {
vector<vector<int>> vv(numRows);
for (int i = 0; i < numRows; ++i)
{
vv[i].resize(i + 1, 1);
}
for (int i = 2; i < numRows; ++i)
{
for (int j = 1; j < i; ++j)
{
vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
}
}
return vv;
}
};3.5.2 移动构造和移动赋值
- 移动构造函数是⼀种构造函数，类似拷⻉构造函数，移动构造函数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引⽤，如果还有其他参数，额外的参数必须有缺省值。构造是资源的复制，移动构造是资源的掠夺。
- 移动赋值是⼀个赋值运算符的重载，他跟拷⻉赋值构成函数重载，类似拷⻉赋值函数，移动赋值函数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引⽤。
- 对于像string/vector这样的深拷⻉的类或者包含深拷⻉的成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第⼀个参数都是右值引⽤的类型，他的本质是要“窃取”引⽤的右值对象的资源，⽽不是像拷⻉构造和拷⻉赋值那样去拷⻉资源，从提⾼效率。下⾯的wsj::string 样例实现了移动构造和移动赋值，我们需要结合场景理解。
void swap(string& s) { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); } // 移动构造 string(string&& s) { cout << "string(string&& s) -- 移动构造" << endl; // 转移掠夺你的资源 swap(s); } // 移动赋值 string& operator=(string&& s) { cout << "string& operator=(string&& s) -- 移动赋值" << endl; swap(s); return *this; }
namespace wsj
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
// 构造
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// 拷贝构造
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动构造" << endl;
// 转移掠夺你的资源
swap(s);
}
// 拷贝赋值
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷贝赋值" <<
endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
// 析构
~string()
{
cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity *
2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
}
int main()
{
wsj::string s1("xxxxx");
// 拷⻉构造
wsj::string s2 = s1;
// 构造+移动构造，优化后直接构造
wsj::string s3 = wsj::string("yyyyy");
// 移动构造
wsj::string s4 = move(s1);
cout << "******************************" << endl;
return 0;
}3.5.3 右值引⽤和移动语义解决传值返回问题
namespace wsj
{
string addStrings(string num1, string num2)
{
string str;
int end1 = num1.size() - 1, end2 = num2.size() - 1;
int next = 0;
while (end1 >= 0 || end2 >= 0)
{
int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
int ret = val1 + val2 + next;
next = ret / 10;
ret = ret % 10;
str += ('0' + ret);
}
if (next == 1)
str += '1';
reverse(str.begin(), str.end());
cout << "******************************" << endl;
return str;
}
}
int main()
{
// 场景1
wsj::string ret = wsj::addStrings("11111", "2222");
cout << ret.c_str() << endl;
// 场景2
wsj::string ret2;
ret2 = wsj::addStrings("11111", "2222");
cout << ret2.c_str() << endl;
return 0;
}一、右值对象构造，只有拷⻉构造，没有移动构造的场景
- 图1展⽰了vs2019 debug环境下编译器对拷⻉的优化，左边为不优化的情况下，两次拷⻉构造，右边为编译器优化的场景下连续步骤中的拷⻉合⼆为⼀变为⼀次拷⻉构造。
图1：
二、右值对象构造，有拷⻉构造，也有移动构造的场景
- 图2展⽰了vs2019 debug环境下编译器对拷⻉的优化，左边为不优化的情况下，两次移动构造，右 边为编译器优化的场景下连续步骤中的拷⻉合⼆为⼀变为⼀次移动构造。
注意：
- 需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码优化为⾮常恐怖，会直接 将str对象的构造，str拷⻉构造临时对象，临时对象拷⻉构造ret对象，合三为⼀，变为直接构造。 要理解这个优化要结合局部对象⽣命周期和栈帧的⻆度理解，如图3所⽰。
- linux下可以将下⾯代码拷⻉到test.cpp⽂件，编译时⽤ g++ test.cpp -fno-elide-constructors 的⽅式关闭构造优化，运⾏结果可以看到图1左边没有优化的两次移动。
图2：
图3：
三、右值对象赋值，只有拷⻉构造和拷⻉赋值，没有移动构造和移动赋值的场景
- 图4左边展⽰了vs2019 debug和 g++ test.cpp -fno-elide-constructors 关闭优化环境 下编译器的处理，⼀次拷⻉构造，⼀次拷⻉赋值。
- 需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码会进⼀步优化，直接构造 要返回的临时对象，str本质是临时对象的引⽤，底层⻆度⽤指针实现。运⾏结果的⻆度，我们可以 看到str的析构是在赋值以后，说明str就是临时对象的别名。
图4：
四、右值对象赋值，既有拷⻉构造和拷⻉赋值，也有移动构造和移动赋值的场景
- 图5左边展⽰了vs2019 debug和 g++ test.cpp -fno-elide-constructors 关闭优化环境 下编译器的处理，⼀次移动构造，⼀次移动赋值。
- 需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码会进⼀步优化，直接构造 要返回的临时对象，str本质是临时对象的引⽤，底层⻆度⽤指针实现。运⾏结果的⻆度，我们可以 看到str的析构是在赋值以后，说明str就是临时对象的别名。
图5：
3.6传值返回问题总结：
1.没有移动构造和移动赋值的情况：
1.1没有涉及拷贝赋值的情况：
- 传值返回对象时，理论上会触发两次拷贝构造（C++11 前）：
- 第一步：将函数内的局部对象拷贝到临时对象（返回值临时量）。
- 第二步：将临时对象拷贝到函数外的接收对象。
- 对于包含动态内存的类型（如vector、string），深拷贝的开销会随数据量增大而显著增加，甚至可能成为性能瓶颈。
- 现代编译器（如 GCC、Clang、MSVC）会通过返回值优化除冗余拷贝，优化后，原本的两次拷贝会被合并为一次直接构造，彻底避免拷贝代价。
- 但是这个优化并非C++标准强制要求，也就是说是否优化取决于编译器，如果编译器不进行优化，会导致拷贝构造的代价依然存在。
1.2涉及拷贝赋值的情况：
- 当函数传值返回的对象被用于拷贝赋值（而非初始化新对象）时，理论上会产生两次深拷贝相关操作：
- 第一步：函数内的局部对象拷贝构造生成临时对象（返回值临时量）。
- 第二步：临时对象拷贝赋值给已存在的接收对象（如下图中的 ret = addString(); 中，ret 是预先定义的对象）。
- 经过现代编译器的优化后，下述示例的开销从 “一次拷贝构造 + 一次拷贝赋值” 简化为 “一次拷贝赋值”，但本质仍是深拷贝操作（对于 vector、string 等类型，代价依然存在）。
1.3总结：
- 无拷贝赋值场景（初始化）：依赖编译器优化，可彻底消除拷贝，通过直接构造接收对象，完全避免深拷贝代价。
- 有拷贝赋值场景（对已有对象赋值）：即使编译器优化，最多只能消除临时对象，仍需执行一次拷贝赋值（深拷贝）。因为接收对象已存在，无法通过 “直接构造” 替代赋值，拷贝代价无法完全规避。
2.C++11增加移动构造和移动赋值之后
2.1没有涉及拷贝构造的情况
- 没有编译器优化时，局部对象的传值返回会触发两次移动构造
- 第一步：将函数内的局部对象（右值）通过移动构造生成临时对象（返回值临时量）。
- 第二步：将临时对象（右值）通过移动构造初始化函数外的接收对象。
- 移动构造是 “资源转移”（浅拷贝 + 原对象资源置空），两次移动的总代价依然很小（远低于深拷贝）
- 经过编译器优化后，直接在接收对象的内存中构造局部对象，完全消除两次移动构造，等价于 “直接构造”，此时，优化前后的性能差异极小：
- 未优化：两次移动构造（代价可忽略）。
- 优化后：一次直接构造（代价与两次移动接近，甚至更低）。
2.2没有涉及拷贝构造的情况
- 没有编译器优化时，当函数传值返回的对象被用于赋值给已有对象（而非初始化新对象）时，C++11 后的行为如下：
- 第一步：函数内的局部对象（右值）通过移动构造生成临时对象（返回值临时量）。（原因：局部对象即将销毁，编译器自动将其视为右值，触发移动构造而非拷贝构造）
- 第二步：临时对象（右值）通过移动赋值给已存在的接收对象（如 ret = addString(); 中，ret 预先定义）。
- 两次操作均为 “资源转移”（移动构造 + 移动赋值），无深拷贝，总代价极小。
- 现代编译器会消除临时对象，直接将函数内的局部对象通过移动赋值传递给接收对象
- 未优化：一次移动构造 + 一次移动赋值（代价可忽略）。
- 优化后：一次移动赋值（代价更低，几乎无差异）。
2.3总结
C++11 引入移动构造和移动赋值后，即使没有编译器优化，传值返回的代价也从 “深拷贝”（高成本）降为 “移动操作”（低成本，资源转移），从根本上避免了深拷贝的性能问题。
3.C++11之前是如何优化传值返回问题的
优化前：
class Solution { public: // 这⾥的传值返回拷⻉代价就太⼤了 vector<vector<int>> generate() { // 实现... return vv; } }; int main() { vector<vector<int>> ret = Solution().generate(); return 0; }
- 通过输出型引用参数（或指针）替代传值返回。
- 相比指针，引用参数更安全（避免空指针风险）且语法更简洁，是更推荐的写法。
class Solution { public: // 传输出型参数，取消传值返回 void generate(vector<vector<int>>& vv) { // 实现... } }; int main() { vector<vector<int>> ret; Solution().generate(ret); return 0; }
3.7类型分类
- C++11以后，进⼀步对类型进⾏了划分，右值被划分纯右值(pure value，简称prvalue)和将亡值 (expiring value，简称xvalue)。
- 纯右值是指那些字⾯值常量或求值结果相当于字⾯值或是⼀个不具名的临时对象。如： 42、true、nullptr 或者类似 str.substr(1, 2)、str1 + str2 传值返回函数调⽤，或者整形 a、b，a++，a+b 等。纯右值和将亡值C++11中提出的，C++11中的纯右值概念划分等价于 C++98中的右值。
- 将亡值是指返回右值引⽤的函数的调⽤表达式和转换为右值引⽤的转换函数的调⽤表达，如 move(x)、static_cast(x)
- 将亡值是指返回右值引⽤的函数的调⽤表达式和转换为右值引⽤的转换函数的调⽤表达，如 move(x)、static_cast(x)
- 泛左值(generalized value，简称glvalue)，泛左值包含将亡值和左值。
- 值类别 - cppreference.com和Value categories这两个关于值类型的中⽂和英⽂的官⽅⽂档，有兴 趣可以了解细节。
3.8 引⽤折叠
- C++中不能直接定义引⽤的引⽤如 int& && r = i; ，这样写会直接报错，通过模板或typedef中的类型操作可以构成引⽤的引⽤。
typedef int& lref; typedef int&& rref; int n = 0; int& && r = n;// 报错，不能定义引用的引用 lref& r1 = n; // r1 的类型是 int& lref&& r2 = n; // r2 的类型是 int& rref& r3 = n; // r3 的类型是 int& rref&& r4 = 1; // r4 的类型是 int&&
- 通过模板或typedef中的类型操作可以构成引⽤的引⽤时，这时C++11给出了⼀个引⽤折叠的规 则：右值引⽤的右值引⽤折叠成右值引⽤，所有其他组合均折叠成左值引⽤。
（即：只要两个引用中有一个是左值引用，最终都会被引用折叠成左值引用，如果两个引用都是右值引用，最终会被引用折叠成右值引用。）- 像f2这样的函数模板中，T&& x参数看起来是右值引⽤参数，但是由于引⽤折叠的规则，他传递左值时就是左值引⽤，传递右值时就是右值引⽤，有些地⽅也把这种函数模板的参数叫做万能引⽤。
// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤ template<class T> void f1(T& x) {} // 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤ template<class T> void f2(T&& x) {} int main() { int n = 0; // 没有折叠->实例化为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) // const的左值引用能传左值也可以传右值，因为不涉及权限放大的问题 f1<const int&>(n); f1<const int&>(0); // 折叠->实例化为void f1(const int& x) // const的左值引用能传左值也可以传右值，因为不涉及权限放大的问题 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; }
- Function(T&& t)函数模板程序中，假设实参是int右值，模板参数T的推导int，实参是int左值，模板参数T的推导int&。如果实参带有const，推导时会保留const属性。再结合引⽤折叠规则，就实现了实参是左值，实例化出左值引⽤版本形参的 Function，实参是右值，实例化出右值引⽤版本形参的Function。
template<class T> void Function(T&& t) { // 该函数模板用于验证T的类型 int a = 0; T x = a; x++; cout << &a << endl; cout << &x << endl; cout << x << " " << a << endl << endl; } int main() { // 10是右值，推导出T为int，模板实例化为void Function(int&& t) Function(10); int a; // a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) Function(a); // std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) Function(std::move(a)); const int b = 8; // b是const左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t) // 所以Function内部会编译报错，x不能++ Function(b); // std::move(b)是cosnt右值，推导出T为const int，模板实例化为void Function(const int&& t) // 所以Function内部会编译报错，x不能++ Function(std::move(b)); return 0; }
3.9完美转发
- Function(T&& t)函数模板程序中，传左值经过引用折叠实例化以后是左值引用的Function函数，传右值经过引用折叠实例化以后是右值引⽤的Function函数。
（因此Function(T&& t)函数模板称之为万能函数模板）- 但是变量表达式都是左值属性，也就意味着⼀个右值被右值引⽤绑定 后，右值引⽤变量表达式的属性是左值（右值引用的属性也是左值），也就是说Function函数中t的属性是左值，那么我们把t传递给下⼀层函数Fun，那么匹配的都是左值引⽤版本的Fun函数。这⾥我们想要保持t对象的属性， 就需要使⽤完美转发实现。
template T&& forward (typename remove_reference::type& arg); template T&& forward (typename remove_reference::type&& arg)； template <class _Ty> _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue return static_cast<_Ty&&>(_Arg); }
- 完美转发forward本质是⼀个函数模板，他主要还是通过引⽤折叠的⽅式实现，下⾯⽰例中传递给 Function的实参是右值，T被推导为int，没有折叠，forward内部t被强转为右值引⽤返回；传递给 Function的实参是左值，T被推导为int&，引⽤折叠为左值引⽤，forward内部t被强转为左值引⽤返回。
（std::forward 无法转发 const 限定的右值）void Fun(int& x) { cout << "左值引用" << endl; } void Fun(const int& x) { cout << "const 左值引用" << endl; } void Fun(int&& x) { cout << "右值引用" << endl; } void Fun(const int&& x) { cout << "const 右值引用" << endl; } template<class T> void Function(T&& t) { //Fun(t); Fun(forward<T>(t)); } int main() { // 10是右值，推导出T为int，模板实例化为void Function(int&& t) // t是右值引用，如果没有完美转发会变成左值引用 Function(10); int a; // a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) // t是左值引用 Function(a); // std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) // t是右值引用，如果没有完美转发会变成左值引用 Function(std::move(a)); const int b = 8; // b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t) // t是const左值引用 Function(b); // std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t) // t是const右值引用，如果没有完美转发会变成const左值引用 Function(std::move(b)); return 0; }
扫一扫
1586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
