C++11

muzi_liii2025-05-12 10:49

文章目录

  • （一）关于C++11版本
  • （二）C++11新增的功能
    • [2.1 列表初始化](#2.1 列表初始化)
    • [2.2 C++11中的std::initializer_list](#2.2 C++11中的std::initializer_list)
    • [2.3 右值引用和移动语义](#2.3 右值引用和移动语义)
      • [2.3.1 左值和右值](#2.3.1 左值和右值)
      • [2.3.2 左值引用和右值引用](#2.3.2 左值引用和右值引用)
      • [2.3.3 引用延长生命周期](#2.3.3 引用延长生命周期)
      • [2.3.4 左值和右值的参数匹配](#2.3.4 左值和右值的参数匹配)
    • [2.4 右值引用和移动语义的使用场景](#2.4 右值引用和移动语义的使用场景)
      • [2.4.1 移动构造和移动赋值](#2.4.1 移动构造和移动赋值)
      • [2.4.2 右值引用和移动语义在传参中的提效](#2.4.2 右值引用和移动语义在传参中的提效)

（一）关于C++11版本

C++11是C++的第二个主要版本，并且是从C++98起的最重要更新。它引入了大量的更改，标准化了既有实践，并改进了对C++程序员可用的抽象。

（二）C++11新增的功能

2.1 列表初始化

与C++11相比，C++98一般只有数组和结构体才可以用"{}"进行初始化，但在C++11以后一切对象皆可以用"{}"进行初始化，这样就统一了初始化方式，"{}"初始化也叫作列表初始化。内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化了以后变成直接构造

代码举例：

C++98：

cpp 复制代码 
//C++98的{}初始化
struct Point
{
	int _x;
	int _y;
};
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[1] = { 5 };
	Point p = { 8,9 };
	return 0;
}

C++11：

cpp 复制代码 
//C++11的{}初始化
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{ }
	Date(const Date& d)
		:_year(d._year)
		,_month(d._month)
		,_day(d._day)
	{ }
private:
	int _year;
	int _month;
	int _day;
};
void Print(const Date& d)
{
	//...
}
int main()
{
	//内置类型支持{}初始化
	int a = { 1 };
	//自定义类型同样也支持
	Date d1 = { 2025,5,10 };
	Date d2 = { 2025 };

	//本质都是由构造函数支持的隐式类型转换
	Date d3 = 2023;//C++98支持
	Date d4 = { 2023,12,19 };//C++11支持
	const Date& d5 = 2021; //C++98支持
	const Date& d6 = { 2025,12,19 };//C++11支持

	//C++11列表初始化的便利性
	Print({ 2018,10,9 });
	Print(2022);
	Print({ 2022,3 });
	
	//可以省略"="
	int b{ 3 };
	Date d7{ 2022,3,4 };
	const Date& d8{ 2000 };
	return 0;
}

2.2 C++11中的std::initializer_list

列表初始化已经很方便了，但是对容器初始化就不太方便了，比如一个vector对象，若要用N个值去构造初始化，而N是不确定的，那么需要实现很多个构造函数才支持，所以C++11库中提出了一个std::initializer_list的类，该类也是一个容器但特殊的是它在底层开一个数组，内部有两个指针分别指向数组的开始和结束，所以可以支持任意多个同类型的对象，从头开始遍历数组，将数据拷贝依次拷贝到需要初始化的容器中。当容器支持一个std::initializer_list的构造函数，也就支持任意多个值的构造函数。std::initializer_list本质上就是支持容器的初始化。

代码举例：

cpp 复制代码 
int main()
{
	auto il = { 1,2,3,4,5 }; //il的类型就是initializer_list
	cout << typeid(il).name() << endl;

	//实际上就是遍历initializer_list然后对数据依次进行push_back操作
	vector<int> v1 = il;
	vector<int> v2 = { 6,7,8,9,10,11 };

	v1 = { 11,22,33,44 };

	//map容器的初始化
	map<string, string> map1 = { {"sort","排序"},{"string","字符串"}};
	//这里其实就是pair对象的{}初始化和map的initializer_list构造结合到一起
	pair<string, string> pair1 = { "sort","排序" };
	pair<string, string> pair2 = { "auto","自动的" };
	map<string, string> map2 = { pair1,pair2 };
	return 0;
}

2.3 右值引用和移动语义

C++11新增了右值引用的语法特性，但无论是左值引用还是右值引用，都是给对象取别名

2.3.1 左值和右值

左值 ：左值是一个表示数据的表达式（如：变量名、解引用的指针），一般是有持久状态，存储在内存空间中，可以取到它的地址，其可以出现在赋值符号的左边或者右边。定义时const修饰后的左值，不能给他赋值，但是可以取到它的地址。
右值 ：数据表达式，要么是字面值常量（如：1，1.1），要么是表达式求值过程中创建的临时对象（如：a+b），右值只能出现在赋值符号的右边，右值不能取地址。

代码举例：

左值：能取地址

cpp 复制代码 
int main4()
{
	int a = 1;
	int* p = new int(10);
	const int b = 2;
	*p = 0;
	string s1("111111");
	s1[0] = 'x';
	cout << &b << endl;
	cout << (void*)&s1[0] << endl;//&s1[0]是一个char*，该char*打印的是字符，不是地址，所以要进行强转
	return 0;
}

右值：不能取地址

cpp 复制代码 
int main()
{
	double x = 1.1, y = 2.2;
	10; //字面常量
	x + y; //表达式求值
	fmin(x, y);//fmin返回一个临时对象
	string("22222"); //匿名对象

	cout << &(x + y) << endl;
	cout << &fmin(x, y) << endl;
	cout << &string("22222") << endl;
	return 0;
}

2.3.2 左值引用和右值引用

右值引用与左值引用没有太大的区别，都是取别名，左值引用就是给左值取别名，右值引用就是给右值取别名。

cpp 复制代码 
int main()
{
	//Type& r1 = x (左值引用)
	int a = 10;
	int& r1 = a; //左值引用
	//Type&& rr1 = y;（右值引用）
	int&& rr1 = 20; 
	return 0;
}
  • 左值引用不能直接引用右值，需要用const修饰
  • 右值引用不能直接引用左值，需要用到move函数
cpp 复制代码 
int main()
{
	int x = 1, y = 2;
	//左值引用右值
	const int& r1 = x + y;
	
	//右值引用左值
	int&& rr1 = move(x);
	//move函数本质上是一中强制类型转换：int&& rr1 = (int&&)x;
	return 0;
}

注意：左值引用的变量是左值属性，右值引用的变量也是左值属性，所以上面的代码中的r1和r11这里个变量都是可以取地址的

2.3.3 引用延长生命周期

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

cpp 复制代码 
class AA
{
public:
	AA(int a1,int a2)
		:_a1(a1)
		,_a2(a2)
	{ }
	~AA()
	{
		cout << "~AA()" << endl;
	}
private:
	int _a1;
	int _a2;
};
int main()
{
	AA aa1(1, 1);//生命周期在整个局部域

	//匿名对象的生命周期只在当前这一行
	AA aa2(2,2);
	
	cout << "-------------------------" << endl;
	return 0;
}

当被左值或右值引用时

cpp 复制代码 
int main()
{
	AA aa1(1, 1);//生命周期在整个局部域

	//匿名对象的生命周期只在这一行
	const AA& r1 =  AA(2, 2);//对匿名对象进行左值引用之后，生命周期被延长
	AA&& rr2 = AA(3, 3);//对匿名对象进行右值引用之后，生命周期被延长
	cout << "-------------------------" << endl;
	return 0;
}

2.3.4 左值和右值的参数匹配

在C++98中，当实现一个用const左值引用作为参数的函数时，那么实参传递左值或者右值都可以匹配，但是如果还实现了左值引用和右值引用作为参数的函数，那么会最先匹配对应的函数（一句话概括：有最符合的匹配最符合的）

cpp 复制代码 
void f(const int& x)
{
	cout << "const左值引用重载" << endl;
}
void f(int& x)
{
	cout << "左值引用重载" << endl;
}
void f(int&& x)
{
	cout << "右值引用重载" << endl;
}
int main()
{
	int i = 10;
	const int ci = 2;
	f(i); //调用f(int& x)
	f(ci); //调用f(const int& x)
	f(3); //调用f(int&& x)
	f(move(i)); //调用f(int&& x)

	//注：左值引用和右值引用的变量表达式的属性还是左值
	int& r1 = i;
	f(r1); //调用f(int& x)
	int&& rr2 = 3;
	f(rr2); //调用f(int& x)
	f(move(rr2)); //调用f(int&& x)
	return 0;
}

2.4 右值引用和移动语义的使用场景

我们知道，左值引用一般使用在函数中左值引用传参和左值引用传返回值，这样可以减少拷贝，同时还可以修改实参和修改返回值对象，但是左值引用没能彻底解决传值返回的问题，来看下面的代码

cpp 复制代码 
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;
}

代码中可以看到，传值返回的代码太大了，返回str会先创建一个临时对象，再去构造一个string对象，若直接用引用传返回值也解决不了问题，因为这里的本质是返回一个局部对象，函数结束这个对象就销毁了，引用返回也无法改变对象已经销毁这个事实

解决办法：移动构造

2.4.1 移动构造和移动赋值

  • 移动构造实际上也是一种构造函数，类似拷贝构造函数，移动构造要求第一个参数的类型是右值引用，如果还有其他参数，额外的参数必须有缺省值
  • 移动赋值实际上是一种赋值运算符重载，跟拷贝赋值构成函数重载，类似拷贝赋值函数，移动赋值函数要求第一个参数的类型是右值引用

为深入学习它们，模拟实现了一个简单的string类：

cpp 复制代码 
namespace li
{
	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);
		}
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		//移动构造
		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;
	};
}

可以看到代码中实现了移动构造和移动赋值，它们的本质实际上就是移动（掠夺）临时对象/匿名对象的资源，因为右值引用大多引用的都是将亡的资源，相当于该资源本来将要销毁，不如给"我"，而且相比于拷贝构造和移动赋值，它们减少了拷贝

cpp 复制代码 
namespace li
{
	int main()
	{
		//构造
		li::string s1("11111");
	
		//构造+移动构造，编译器优化成直接构造
		li::string s2 = li::string("2222"); 
		//若没有移动构造，就会进行构造+拷贝构造，编译器也会优化成拷贝狗杂

		//移动构造
		li::string s3 = move(s1);
		//若没有移动构造，就会进行拷贝构造
		cout << "------------------------------" << endl;
		return 0;
	}
}

移动构造是如何解决前面提出的问题呢？

有了移动构造就大大减少了传值返回的代价，减少了拷贝。编译器的优化就是直接合二为一，不创建 str，也可以理解为str就是临时对象。

移动赋值的使用：

cpp 复制代码 
int main()
{
	li::string s3;
	s3 = li::addStrings("111", "22"); //这里是赋值不是拷贝
	return 0;
}

所以不管编译器如何优化，传值返回用移动构造和移动赋值的代价都足够低

2.4.2 右值引用和移动语义在传参中的提效

C++11版本以后，很多容器的push和insert系列的接口都增加了右值引用版本，当实参是一个左值时，容器内容继续调用拷贝构造进行拷贝，将对象拷贝到容器空间中的对象，当实参是一个右值时，容器内部则调用移动构造，将右值对象的资源移动到容器空间的对象上

根据下图来进行理解：

用list容器来举例

代码举例：

cpp 复制代码 
int main()
{
	list<li::string> ls;

	//构造+拷贝构造
	li::string s1("1111111");
	ls.push_back(s1);

	//构造临时对象+移动构造
	ls.push_back("2222222");

	cout << "--------------------------" << endl;
	return 0;
}


模拟实现一个简单的list容器的右值版本的push_back：

cpp 复制代码 
#pragma once
#include <iostream>
using namespace std;

namespace li
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;

		//左值引用版本
		ListNode(const T& data = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(data)
		{}

		//右值引用版本
		ListNode(T&& data) //默认构造的缺省参数只用给一个
			:_next(nullptr)
			,_prev(nullptr)
			,_data(move(data)) //同样道理，也需要强转成右值属性
		{}
	};

	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;
		ListIterator(Node* node)
			:_node(node)
		{}
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
	};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;

		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}

		list()
		{
			empty_init();
		}

		// 左值引用版本
		void push_back(const T& x)
		{
			insert(end(), x);
		}

		//右值引用版本
		void push_back(T&& x)
		{
			insert(end(), move(x)); 
			//因为右值引用的属性还是左值，所以要将x强转成右值，才能匹配到下一层的右值版本的insert
		}

		//左值引用版本
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);//右值引用的属性还是左值，需要转成右值属性
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}

		//右值引用版本
		iterator insert(iterator pos, T&& x)
		{
			Node* cur = pos._node;

			//右值引用的属性还是左值，需要转成右值属性，才能匹配到下一层的右值版本的默认构造函数
			Node* newnode = new Node(move(x));
			
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}
	private:
		Node* _head;
	};
}

一定要注意：右值引用的变量表达式的属性还是左值！！

相关推荐
虾球xz1 小时前
游戏引擎学习第271天:生成可行走的点
c++·学习·游戏引擎
qq_433554541 小时前
C++ STL编程 vector空间预留、vector高效删除、vector数据排序、vector代码练习
开发语言·c++
XiaoCCCcCCccCcccC1 小时前
Linux网络基础 -- 局域网，广域网，网络协议，网络传输的基本流程，端口号，网络字节序
linux·c语言·网络·c++·网络协议
菜狗想要变强2 小时前
C++ STL入门：vecto容器
开发语言·c++
五花肉村长2 小时前
Linux-Ext系列文件系统
linux·运维·服务器·c++·笔记·visual studio
weixin_428498492 小时前
在Lua中使用轻量级userdata在C/C++之间传递数据和调用函数
c语言·c++·lua
爱看书的小沐2 小时前
【小沐学GIS】基于C++绘制二维瓦片地图2D Map（QT、OpenGL、GIS）
c++·qt·gis·opengl·glfw·glut·二维地图
coding_rui3 小时前
C++模板笔记
c++·模板·类模板
C++ 老炮儿的技术栈3 小时前
C++中什么是函数指针？
c语言·c++·笔记·学习·算法
再睡一夏就好3 小时前
C语言常见的文件操作函数总结
c语言·开发语言·c++·笔记·学习笔记
热门推荐
01【分布式】Hadoop完全分布式的搭建（零基础）02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06西电B测-计算机网络综合实验(含验收问题)07Coze扣子平台完整体验和实践（附国内和国际版对比）08苍穹外卖面试总结09DeepSeek各版本说明与优缺点分析10最新 Kubernetes 集群部署 + flannel 网络插件（保姆级教程，最新 K8S 版本）