走进C++11（上）：核心语法变化与变成范式转变

咩 ꒰๑´•.̫ • `๑꒱本人博客主页------>Cinema KI

<(￣︶￣)>本人gitee主页------>llirving

文章目录

• 前言
• 🍏一、C++11的发展历史
• 🍎二、列表初始化
• • 2.1C++98中的{}
  • 2.2C++11中的{}
  • 2.3C++11中的std::initializer_list
• 🍉三、右值引用和移动语义
• • 3.1左值和右值
  • 3.2左值引用和右值引用
  • 3.3引用延长生命周期
  • 3.4左值和右值的参数匹配
  • 3.5右值引用和移动语义的使用场景(重点)
• 🍇总结

---

前言

• C++11是C++语言发展的里程碑，作为传统C++到现代C++的重要转折点，它带来了大量语法革新与特性升级，既解决了旧版开发的诸多痛点，也大幅提升了编码效率与代码优雅性，更是后续C++标准的发展基础。

• 本系列将分上下集拆解C++11核心新特性，上集聚焦日常开发高频使用的基础语法与实用特性，从易上手、好落地的知识点出发，结合示例讲清用法与核心要点，助力快速将C++11融入实际开发；下集则深入内存管理、并发编程等进阶内容，完整梳理C++11的能力体系。

---

提示：以下是本篇文章正文内容，下面案例可供参考

🍏一、C++11的发展历史

• C++11是C++的第二个主要版本，并且是从C++98起的最重要更新。它引入了大量更改，标准化了既有实践，并改进了对C++程序员可用的抽象。在它最终由ISO在2011年8月12日采纳前，人们曾使用名称"C++0x"，因为它曾被期待在2010年之前发布。C++03与C++11期间花了8年时间，故而这是迄今为止最长的版本间隔。从那时起，C++有规律地每3年更新一次
• C++的C++也被称为现代C++

🍎二、列表初始化

2.1C++98中的{}

C++98中一般数组和结构体可以用{}初始化
代码示例，如下

struct Date
{
   int _year;
   int _month;
   int _day;
};

int main()
{
   int array1[] = {1,2,3,4,5};
   int array2[5] = {0};
   Date d1 = {2026,1,25};
   return 0;
}

2.2C++11中的{}

• C++11以后想统一初始化方式，试图实现一切对象皆可用{}初始化，{}初始化也叫列表初始化
• 内置类型支持，自定义类型也知此恨，自定义类型本质时类型转换，中间产生临时对象，最后优化了以后变成直接构造
• {}初始化的过程中，可以省略掉=
• C++11列表初始化的本意是想实现一个大一统的初始化方式，其次他有些场景带来不少的遍历，如容器push/insert多参数构造的对象时，{}初始化会很方便
  代码示例，如下

struct Date
{
   int _year;
   int _month;
   int _year;
   Date(int year,int month,int day)
      :_year(year)
      ,_month(month)
      ,_day(day)
   {}
};

int main()
{
   //C++98支持的
   int array1[] = {1,2,3,4,5};
   int array2[5] = {0};
   Date d1 = {2026,1,25};

   //C++11支持的
   int a = {2};//内置类型{}初始化
   Date d2 = {2026,1,25};//自定义类型，这里本质是用{2026,1,25}构造一个临时对象，临时对象那个再去拷贝构造d2，编译器优化最后直接构造
   const Date& d3 = {2025,1,1};//d3引用的是{2025,1,1}构造的临时对象

   //需要注意的是，C++98支持单参数时类型转换，也可以不用{}
   Date d4 = {2025};
   Date d5 = 2025;
   
   //C++11{}构造，=可以省略
   int x{2};
   Date d6{2025,1,1};
   const Date& d7{2025,1,1};

   
}

---

2.3C++11中的std::initializer_list

• 上面的初始化已经很方便，但是对象容器初始化还是不太方便，比如一个vector对象，我想用N个值去构造初始化，那么我们得实现很多个构造函数才能支持
• C++11库中提出了一个std::initializer_list 的类，auto il= {10，20，30}，这个类的本质是底层开一个数组，将数拷贝过来，有两个指针分别指向数组的开始和结束
• 容器支持一个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());
// ...
template<class T>
class vector {
public:
   typedef T* iterator;
   vector(initializer_list<T> l)
   {
      for (auto e : l)
      push_back(e)
   }
private:
   iterator _start = nullptr;
   iterator _finish = nullptr;
   iterator _endofstorage = nullptr;
};
//...
// 另外，容器的赋值也⽀持initializer_list的版本
vector& operator= (initializer_list<value_type> il);
map& operator= (initializer_list<value_type> il);
//
int main()
{
   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 };
   const vector<int>& v3 = { 1,2,3,4,5 };
   // 这⾥是pair对象的{}初始化和map的initializer_list构造结合到⼀起⽤了
   map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"}};
   // initializer_list版本的赋值⽀持
   v1 = { 10,20,30,40,50 };
   return 0;
}

---

🍉三、右值引用和移动语义

相较于C++98，这块内容更是C++11新增的内容，这块非常的重要，请大家务必牢牢掌握原理与用法。

3.1左值和右值

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

int main()
{
   //以下是常见的左值，均可以取地址
   int* p = new int(10);
   int b = 1;
   const int c = b;//这也就说明了左值不一定能修改
   *p = 10;
   string s("chenzehong");
   s[0] = 'a';
   
   cout<<&s<<endl;
   cout<<(void*)&s[0]<<endl;//这里的s[0]是char*，假设不强转的化，打印char*通常是把它指向的字符串打印出来，而不是打印地址

   //右值，不能取地址
   double x = 1.1,y = 2.2;//这里的x,y均是右值
   x+y//表达式求值，右值
   10;//字面值常量，右值
   fmin(x+y);//fmin函数是传值返回，传值返回会返回临时对象，临时对象生命期不持久，右值
   string("1111");//匿名对象，生命周期只在当前行数，同样不持久，右值
}

3.2左值引用和右值引用

• Type& r1 = x;Type&& r2 = y;第一个语句就是左值引用，左值引用就是给左值取别名，第二个语句为右值引用，同样的道理，右值引用就是给右值取别名
• 左值引用不能直接引用右值，但是const左值引用可以引用右值(因为const表示不能修改，右值基本上都无法修改)
• 右值引用不能引用左值，但是右值引用可以引用move之后的左值这个后面会讲
• template<class T> typename remove_reference<T>::type&&move(T && arg);
• move是我们库里面的一个函数模板，本质内部是进行强制类型转换，当然它还涉及一些引用折叠的知识，后面会细讲
• 需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量表达式的属性是左值

int main()
{
   //左值
   int* p = new int(10);
   int b = 1;
   const int c = b;
   *p = 10;
   string s("111");
   s[0] = 'x';
   double x = 1.1,y = 1.1;

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

   //右值引⽤给右值取别名
   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;

   // 上面的rr1引用了一个右值，引用后rr1属于左值属性，所以rrx6引用rr1要move一下
   int& r6 = r1;
   // int&& rrx6 = rr1;
   int&& rrx6 = move(rr1);
}

3.3引用延长生命周期

右值本身声明周期就很短，想要延长这个右值可以使用右值引用；也可以const左值引用，但这些对象无法被修改

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;
}

3.4左值和右值的参数匹配

• C++98中，我们实现一个const左值引用作为参数的函数，实参传左值和右值都可以匹配
• C++11以后，分别重载f函数的形参为左值引用、const左值引用、右值引用，那么实参是左值会匹配f(左值引用)、实参是const左值会匹配f(const左值引用)、实参是右值会匹配f(右值引用)
• 右值引用的变量在用于表达式时属性是左值，这个设计这里会感觉很怪，下一小节我们讲右值引用的使用场景时，就能体会这样设计的价值了

#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;//x具有左值属性，所以下面调用左值引用的函数
    f(x); // 调⽤ f(int& x)
    f(std::move(x)); // 调⽤ f(int&& x)

    return 0;
}

3.5右值引用和移动语义的使用场景(重点)

左值引用主要使用场景回顾

左值引用主要使用场景是在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用传左值引用返回 ，那么这里用右值返回接收就解决问题了吗？那也是不行的，因为返回的对象是局部对象，函数结束其就销毁了，咱们说了：要引用的对象必须出了函数作用域还存在。显然这里不符合场景。

·代码示例，如下

class Solution {
public:
   // 传值返回需要拷贝
   string addStrings(string num1, string num2) {
5     string str;
6     int end1 = num1.size()-1, end2 = num2.size()-1;
7     // 进位
8     int next = 0;
9     while(end1 >= 0 || end2 >= 0)
10    {
11       int val1 = end1 >= 0 ? num1[end1--]-'0' : 0;
12       int val2 = end2 >= 0 ? num2[end2--]-'0' : 0;
13
14       int ret = val1 + val2+next;
15       next = ret / 10;
16       ret = ret % 10;
17
18       str += ('0'+ret);
19    }
20
21    if(next == 1)
22    str += '1';
23
24    reverse(str.begin(), str.end());
25
26    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;
};

移动构造和移动赋值

• 移动构造函数是⼀种构造函数，类似拷⻉构造函数，移动构造函数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引⽤，如果还有其他参数，额外的参数必须有缺省值
• 移动赋值是⼀个赋值运算符的重载，他跟拷⻉赋值构成函数重载，类似拷⻉赋值函数，移动赋值函数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引⽤
• 对于像string/vector这样的深拷⻉的类或者包含深拷⻉的成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第⼀个参数都是右值引⽤的类型，他的本质是要"窃取"引⽤的右值对象的资源，⽽不是像拷⻉构造和拷⻉赋值那样去拷⻉资源，从提⾼效率。下⾯的Zehong::string样例实现了移动构造和移动赋值，我们需要结合场景理解。

namespace Zehong
{
	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& tmp)
		{
			std::swap(_str, tmp._str);
			std::swap(_size, tmp._size);
			std::swap(_capacity, tmp._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;
		}

		// s4 = bit::string("yyyyy");
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;

			swap(s);
			return *this;
		}

		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';
		}

		char& operator[](size_t pos)
		{
			//assert(pos < _size);
			return _str[pos];
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}

		bool operator<(const string& s) const
		{
			return strcmp(_str, s._str) < 0;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}
int main()
{
    Zehong::string s1("xxxxx");//1
    // 拷⻉构造
    Zehong::string s2 = s1;//2
    // 构造+移动构造，优化后直接构造
    Zehong::string s3 = bit::string("yyyyy");//3
    // 移动构造
    Zehong::string s4 = move(s1);//4
    cout << "******************************" << endl;//5

    return 0;
 }

• 视角转到main函数中
• 第一行代码构造了一个左值的string对象s1，第二行通过拷贝构造将s1拷贝给了s2
• 第三行代码创建了一个匿名对象，并将这个匿名对象拷贝给了s3，编译器识别到了这个匿名对象是一个右值，即将销毁，所以指向这个匿名对象的资源的指针，由s3来指向，然后这个匿名对象销毁，这样的好处在于不用我们自己去创建临时对象，你不是即将销毁嘛，我直接夺走你的资源，然后你再销毁，这样我就不用自己去开空间了 （移动构造）
• 第四行代码，将move(s1)拷贝给了s4，也是调用移动构造,move(左值)会在那一瞬间变成右值，内部的资源不再由s1自己指向，而是被s4"抢夺了"，此行代码执行完，s1内部指针会置空

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

string addStrings(string num1, string num2)
{
		string str;
		cout << &str << endl;
		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;
}

// 场景1
int main()
{
    Zehong::string ret = bit::addStrings("11111", "2222");
    cout << ret.c_str() << endl;
    return 0;
}
// 场景2
int main()
{
    Zehong::string ret;
    ret = bit::addStrings("11111", "2222");
    cout << ret.c_str() << endl;
    return 0;
}

• 第一个main函数，核心：直接初始化，编译器会触发EVO优化，在ret的内存空间里直接构造结果，没有额外拷贝或移动（移动构造）
• 第二个main函数，核心：分两步，先默认构造一个空ret，再通过移动赋值把结果转移给ret，比场景1多了一次默认构造的开销

1. C++98 时代（比如 GCC 3.0）

• 没有移动语义，也没有 RVO 优化。
• 场景1： ret = addStrings(...) → 会触发 2 次拷贝构造（函数返回时拷贝一次，初始化 ret 时再拷贝一次）。
• 场景2： ret; ret = addStrings(...) → 会触发 1 次拷贝构造（函数返回） + 1 次拷贝赋值。
• 性能开销很大，完全没有优化。

2. C++11 时代（比如 GCC 4.8）

• 引入了移动语义和强制 RVO（NRVO）。
• 场景1： ret = addStrings(...) → 编译器会触发 RVO，直接在 ret 的内存里构造对象，零拷贝、零移动。
• 场景2： ret; ret = addStrings(...) → 默认构造 + 1 次移动赋值，比 C++98 高效很多。

3. 现代 C++（比如 GCC 12 / Clang 15）

• RVO 优化更成熟，甚至能跨函数优化。
• 场景1：几乎 100% 触发 RVO，完全没有拷贝或移动。
• 场景2：默认构造 + 移动赋值，且移动赋值的开销被进一步优化到接近零。

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

• 查看STL⽂档我们发现C++11以后容器的push和insert系列的接⼝否增加的右值引⽤版本
• 当实参是⼀个左值时，容器内部继续调⽤拷⻉构造进⾏拷⻉，将对象拷⻉到容器空间中的对象
• 当实参是⼀个右值，容器内部则调⽤移动构造，右值对象的资源到容器空间的对象上

1 // void push_back (const value_type& val);
2 // void push_back (value_type&& val);
3 // iterator insert (const_iterator position, value_type&& val);
4 // iterator insert (const_iterator position, const value_type& val);
int main()
{
    std::list<bit::string> lt;

    Zehong::string s1("111111111111111111111");
    lt.push_back(s1);
    cout << "*************************" << endl;

    lt.push_back(bit::string("22222222222222222222222222222"));
    cout << "*************************" << endl;

    lt.push_back("3333333333333333333333333333");
    cout << "*************************" << endl;

    lt.push_back(move(s1));
    cout << "*************************" << endl;

    return 0;
}

 运⾏结果：
string(char* str)
string(const string& s) -- 拷⻉构造
*************************
string(char* str)
string(string&& s) -- 移动构造
~string() -- 析构
*************************
string(char* str)
string(string&& s) -- 移动构造
~string() -- 析构
*************************
string(string&& s) -- 移动构造
*************************
~string() -- 析构
~string() -- 析构
~string() -- 析构
~string() -- 析构
~string() -- 析构

🍇总结

以上就是本文的全部内容，重点掌握左值和右值的区分，并且直到左值和右值的使用场景，进而理解这样的使用带来的什么样的好处。