C++11新特性详解（上）：从列表初始化到右值引用

永远睡不够的入2026-04-26 9:05

C++11新特性详解（上）：从列表初始化到右值引用


递归何不归：个人主页
个人专栏 : 《C++庖丁解牛》《数据结构详解》

在广袤的空间和无限的时间中，能与你共享同一颗行星和同一段时光，是我莫大的荣幸

一、列表初始化

1.1 C++98中的列表初始化

在C++98中，一般数组和结构体支持列表初始化

cpp 复制代码 
 struct Point
{
     int _x;
     int _y;
};
int main()
{
     int array1 [] = { 1 , 2 ,3 ,4 ,5 };
     int array2[5] = { 0 };
     Point p = { 1 , 2 };
     return 0;
}

1.2 C++11中的列表初始化

  • 在C++11中，列表初始化的适用范围明显扩大了，列表初始化被有意的打造成一个万能的初始化方式
  • 自定义类型也支持{}初始化 ，只不过是先构造再拷贝，中间会产生临时对象，但是往往会被直接优化成直接构造
  • {}初始化的过程中，可以省略掉=
  • C++11列表初始化的本意是想实现一个大统一的初始化方式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很方便
cpp 复制代码 
#include<vector>
#include<iostream>
#include<map>
#include<string>
#include<assert.h>
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 };

	// C++11支持的
	// 内置类型支持
	int x1 = { 2 };
	int x2 = 2;

	// 自定义类型支持
	// 这里本质是用{ 2025, 1, 1}构造一个Date临时对象
	// 临时对象再去拷贝构造d1，编译器优化后合二为一变成{ 2025, 1, 1}直接构造初始化d1
	// 运行一下，我们可以验证上面的理论，发现是没调用拷贝构造的
	Date d1 = { 2025, 1, 1 };
	Date d20(2025, 1, 1);

	// 这里d2引用的是{ 2024, 7, 25 }构造的临时对象
	const Date& d2 = { 2024, 7, 25 };

	// 需要注意的是C++98支持单参数时类型转换，也可以不用{}
	Date d3 = { 2025 }; // C++11
	Date d4 = 2025;     // C++98
	string str = "1111";

	// 可以省略掉=
	Point p1{ 1, 2 };
	int x3{ 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 });
	map<string, string> dict;
	dict.insert({ "xxx", "yyyy" });

	// 构造+拷贝构造+优化
	//vector<int> v1 = { 1,2,3,4 };
	//vector<int> v2 = { 10,20,30,1,1,1,1,1,1,1,1,1};
	//const vector<int>& v4 = { 10,20,30,1,1,1,1,1,1,1,1,1 };

	vector<int> v1{ 1,2,3,4 };
	vector<int> v2{ 10,20,30,1,1,1,1,1,1,1,1,1 };
	const vector<int>& v4 { 10,20,30,1,1,1,1,1,1,1,1,1 };

	// 构造
	vector<int> v3({ 10,20,30,1,1,1,1,1,1,1,1,1 });

	initializer_list<int> il1 = { 10, 20, 30, 1, 1, 1, 1, 1, 1, 1, 1, 1};
	int aa1[] = { 10, 20, 30, 1, 1, 1, 1, 1, 1, 1, 1, 1 };

	// initializer_list + {}pair初始化隐式类型转换
	map<string, string> dict = { { "xxx", "yyyy" }, { "sort", "zzzz" } };

	return 0;
}

2.3 C++11中的std::initializer_list

上面的{}初始化已经是很好用了，但是还是存在局限 ，在对容器初始化时每次传入的数据个数都是不同的 ，此时我们就需要一个统一的，普适性的构造方式

  • C++11库中提出了一个std::initializer_list的类，auto il = { 10 , 20 , 30 }; // the
    type of il is an initialize r_list ，这个类的本质是底层开一个数组 ，将数据拷贝
    过来，std::initializer_list内部有两个指针分别指向数组的开始和结束。
  • 这是他的文档：initializer_list，std::initializer_list支持迭代器遍历。
  • 容器支持一个std::initializer_list的构造函数，也就支持任意多个值构成的{x1 ,x2 ,x3 ...}进行
    初始化     。STL中的容器支持任意多个值构成的{x1 ,x2 ,x3 ...}进行初始化，就是通过
    std::initializer_list的构造函数支持的。

简单来说，这种初始化方式就是先将数据储存进initializer_list，再调用容器的迭代器构造，将initialzer_list中的数据转移出来

cpp 复制代码

二、右值引用

2.1 左值和右值

  • 左值是一个表示数据的表达式，一般是有持久状态 ，储存在内存中，可以被取地址，可以放在等号的左右两边
  • 右值也是一个表示数据的表达式，要么是字面值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。

简单来说：左值和右值的主要区别就是是否可以取地址

2.2 右值引用和左值引用

  • Type& r1 = x ; Type&& rr1 = y;第一个语句就是左值引用，左值引用就是给左值取别
    名，第二个就是右值引用，同样的道理，右值引用就是给右值取别名。
  • 普通的左值引用不能引用右值，但是const 左值引用可以
  • 右值引用也不可以直接引用左值，但是move之后的左值是可以被右值引用引用的
  • move的底层其实就是强制类型转换，这是因为引用的底层也就是指针，强制类型转换起来还是没什么压力的
  • 右值引用的表达式是左值，也就是说一个右值被右值引用绑定时，右值引用变量表达式的性质是左值（这个现在还看不出来具体作用）
cpp 复制代码 
template<class T>
void func(const T& x)
{}

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;
	cout << (void*)&s[0] << endl;

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


	// 右值：不能取地址
	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;

	// 右值引用给右值取别名
	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;
	//其实完全可以认为是强制类型转换，所以move是完全不影响原来左值的性质的

	// b、r1、rr1都是变量表达式，都是左值
	cout << &b << endl;
	cout << &r1 << endl;
	cout << &rr1 << endl;
	//其实move就是强制类型转换，也就是说move是不会影响被move的值的

	int i = 1;
	int* ptr = (int*)i;

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

	//int&& rrx6 = rr1;
	int&& rrx6 = move(rr1);

	//左值引用的表达式是左值，右值的表达式也是左值

	//一切引用都是指针
	return 0;
}

2.3 右值引用延长生命周期

右值引用可用于为临时对象延长生命周期 ，const 的左值引用也能延长临时对象生存期，但这些对象无法被修改。

cpp 复制代码 
 int main()
{
     std ::string s1 = "Test";
     // std::string&& r1 = s1;          // 错误：不能绑定到左值

     const std ::string& r2 = s1 + s1;    //OK：到const 的左值引用延长生存期
     //  r2 += "Test ";                   // 错误：不能通过到const 的引用修改

     std ::string&& r3 = s1 + s1;         //OK：右值引用延长生存期
     r3 += "Test";                       //OK：能通过到非const 的引用修改

     std ::cout << r3 << '\n ';

     return 0;
}

2.4 右值引用的具体应用场景

2.4.1 左值引用的不足

其实左值引用已经解决了许多的问题，例如引用传参减少拷贝，但是还是有一些场景是解决不了的：

cpp 复制代码 
class Solution {
public:
	// 传值返回需要拷贝
	bit::string addStrings(bit::string num1, bit::string num2) {
		bit::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 << &str << endl;

		return str;
	}
};

此时的返回值是在栈区的临时变量 ，处于函数add这个函数的函数栈桢上 ，在add的生命周期结束后，就会跟着函数栈桢一起销毁，这个时候就只能使用传值传参 ，拷贝构造一个临时值 传回去，再拷贝给返回值 ，这样的效率显然是低下的。

2.4.2 移动构造和移动赋值

  • 移动构造函数是一种构造函数，类似拷贝构造函数，移动构造函数要求第一个参数是该类类型的引用 ，但是不同的是要求这个参数是右值引用，如果还有其他参数，额外的参数必须有缺省值。
  • 移动赋值是一个赋值运算符的重载，他跟拷贝赋值构成函数重载 ，类似拷贝赋值函数，移动赋值函数要求第一个参数是该类类型的引用 ，但是不同的是要求这个参数是右值引用。
  • 对于像string/vector这样的深拷贝的类或者包含深拷贝的成员变量 的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第一个参数都是右值引用的类型 ，他的本质是要**"窃取"引用的右值对象的资源**（实际上就是指针的转移，数据还是存放在原来的位置（堆区）），而不是像拷贝构造和拷贝赋值那样去拷贝资源，从而提高效率。

这种方式在处理这种深拷贝情况时比较好用，但是处理先拷贝情况的话就和拷贝构造无异了，这是因为深拷贝的数据存放在堆区，可以直接交换指针，但是浅拷贝的数据存放在栈区，这时是免不了拷贝的

cpp 复制代码 
namespace bit
{
	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& ss)
		{
			::swap(_str, ss._str);
			::swap(_size, ss._size);
			::swap(_capacity, ss._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;
	};
}

2.4.3 右值引用和移动语义解决传值返回问题

此处使用的还是上面的代码

右值对象构造，只有拷贝构造，没有移动构造的场景
  • 下图展示了vs2019 debug环境下编译器对拷贝的优化，左边为不优化的情况下，两次拷贝构造，右边为编译器优化的场景下连续步骤中的拷贝合二为一变为一次拷贝构造。
  • 需要注意的是在vs2019的release和vs2022的debug和release，下面代码优化为非常恐怖，会直接将str对象的构造，str拷贝构造临时对象，临时对象拷贝构造ret对象，合三为一，变为直接构造。要理解这个优化要结合局部对象生命周期和栈帧的角度理解。
  • linux下可以将下面代码拷贝到test.cpp文件，编译时用g++ test .cpp -fno -elide
    constructors的方式关闭构造优化，运行结果可以看到下图左边没有优化的两次拷贝。


我们会发现："好像编译器自己的优化也可以实现我们想要的结果"，那么使用移动拷贝和移动赋值的意义何在呢？

要知道：不是所有的编译器都会实现优化，移动构造和移动赋值更像是保证下限

右值对象构造，有拷贝构造，也有移动构造的场景
  • 下图展示了vs2019 debug环境下编译器对拷贝的优化，左边为不优化的情况下，两次移动构造，右边为编译器优化的场景下连续步骤中的拷贝合二为一变为一次移动构造。

这里即使是未优化过的版本 ，其效率也是有了很大的进步（指针传递还是好过数据拷贝的）

右值对象赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景
  • 下图左边展示了vs2019 debug和g++ test .cpp -fno -elide -constructors 关闭优化环境
    下编译器的处理，一次拷贝构造，一次拷贝赋值。
右值对象赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景
  • 下图左边展示了vs2019 debug和g++ test .cpp -fno -elide -constructors 关闭优化环境
    下编译器的处理，一次移动构造，一次移动赋值。

2.5 总结

综上所述：右值引用在需要深拷贝的场景下可以显著提高运行效率、减少拷贝，同时还不需要改变原先代码结构，只需要修改类的成员函数，十分甚至是九分的高效

相关推荐
枫叶丹41 小时前
【HarmonyOS 6.0】AVCodec Kit：OH_AVDataSource回调中传递用户自定义数据的深度解析
开发语言·华为·harmonyos
c++圈来了个新人2 小时前
C++类和对象（中）
c语言·开发语言·数据结构·c++·考研·算法
格林威2 小时前
面阵相机 vs 线阵相机：堡盟与海康相机选型差异全解析+python实战演示
开发语言·人工智能·python·数码相机·计算机视觉·视觉检测·工业相机
思麟呀2 小时前
5种IO模型
linux·运维·服务器·c++
Go away, devil2 小时前
Java——IO
java·开发语言
oscar9992 小时前
OpenCode Go ：为开放编码模型准备的低价订阅方案
开发语言·后端·golang
王老师青少年编程2 小时前
csp信奥赛C++高频考点专项训练之贪心算法 --【删数问题】：删数问题2
c++·算法·贪心·csp·信奥赛
.千余2 小时前
【Linux】开发工具2：vim
linux·服务器·开发语言·学习
SWAGGY..2 小时前
【C++初阶】：（10）vector的使用及模拟实现
开发语言·c++
热门推荐
01GitHub 镜像站点022026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元03近期有什么ai的新消息，新动态？ 2026.4月042026年4月AI大事件深度解读：大模型竞争进入“深水区“052026年AI前瞻：量子AI、具身智能与科学发现的新纪元06AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析07codex app每次打开重连5次Reconnecting问题解决082026 年 AI 辅助编程工具全景对比：Copilot、Cursor、Claude Code 与 Codex 深度解析09CC-Switch & Claude 基于 Linux 服务器安装使用指南102026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free