🔥个人主页： Forcible Bug Maker

🔥专栏： C++

目录

🌈前言🔥C++11简介🔥统一的列表初始化（{}初始化）🔥std::initializer_list🔥声明autodecltype

🔥STL中的一些变化🔥右值引用和移动语义左值引用和右值引用左值引用和右值引用比较右值引用的使用场景及意义模板中的&&万能引用 和 完美转发

🌈结语

🌈前言

本篇博客主要内容：C++11的简介，以及其中较为常用的新语法。

之前部分内容都是基于C++98来进行展开的，在最开始几节语法的基础上自实现STL库中的容器，完善容器的过程中逐渐培养起C++的编程思维。C++11的一些新语法可能会对传统C++98的选手们产生一定的冲击，毕竟新语法就是一种新玩法，建议提前做好心理准备，开始本次的内容。

🔥C++11简介

在2003年C++标准委员会曾经提交了一份计数勘误表（简称TC1），使得C++03这个名字取代C++98称为C++11之前的最新C++标准名称。不过由于C++03（TC1）主要时对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准十年磨一剑，第二个真正意义上的标准姗姗来迟。相比于C++98/03，C++11带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一一讲解，所以博客中主要讲解实际中比较实用的语法。

C++11的官方介绍文档

🔥统一的列表初始化（{}初始化）

C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。如：

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

}

C++11扩大了用大括号括起的列表（初始化列表）的使用范围，使其可用于所有的内置类型和用户的自定义类型，使用初始化列表时可添加等号（=），也可不添加：

struct Point

{

int _x;

int _y;

};

int main()

{

int x1 = 1;

int x2{ 2 };

int array1[]{ 1, 2, 3, 4, 5 };

int array2[5]{ 0 };

Point p{ 1, 2 };

// C++11中列表初始化也可以适用于new表达式中

int* pa = new int[4] { 0 };

return 0;

}

创建对象时也可以使用列表初始化方式调用构造函数初始化：

class Date

{

public:

Date(int year, int month, int day)

:_year(year)

, _month(month)

, _day(day)

{

cout << "Date(int year, int month, int day)" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1(2022, 1, 1); // old style

// C++11支持的列表初始化，这里会调用构造函数初始化

Date d2{ 2022, 1, 2 };

Date d3 = { 2022, 1, 3 };

return 0;

}

🔥std::initializer_list

介绍文档地址：戳这里~

<code>std::initializer_list的类型：

int main()

{ -- -->

// the type of il is an initializer_list

auto il = { 10, 20, 30 };

cout << typeid(il).name() << endl;

return 0;

}

<code>std::initializer_list的使用场景：

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样就能便于初始化对象。也可以作为operator=的参数，从而允许用大括号赋值。

<code>

int main()

{ -- -->

vector<int> vt = { 1,2,3,4,5,6,7 };

for (auto& e : vt) {

cout << e << " ";

}

cout << endl << endl;

map<char, int> ma({ { 'a', 1 }, { 'b',2 }, { 'c',3 } });

for (auto& e : ma) {

cout << e.first << ":" << e.second << endl;

}

cout << endl;

ma = { { 'd',4},{ 'e',5} };

for (auto& e : ma) {

cout << e.first << ":" << e.second << endl;

}

cout << endl;

return 0;

}

std::initializer_list提供了这样几个接口，我们可以根据这些接口在实现自己vector的std::initializer_list初始化方式。

<code>template<class T>

class vector { -- -->

public:

typedef T* iterator;

vector(initializer_list<T> l)

{

_start = new T[l.size()];

_finish = _start + l.size();

_endofstorage = _start + l.size();

iterator vit = _start;

typename initializer_list<T>::iterator lit = l.begin();

while (lit != l.end())

{

*vit++ = *lit++;

}

}

vector<T>& operator=(initializer_list<T> l)

{

vector<T> tmp(l);

std::swap(_start, tmp._start);

std::swap(_finish, tmp._finish);

std::swap(_endofstorage, tmp._endofstorage);

return *this;

}

private:

iterator _start;

iterator _finish;

iterator _endofstorage;

};

🔥声明

auto

在C++98中auto是一个存储类型说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样就要求必须显示初始化，让编译器将自定义类型设置为初始化值类型。

int main()

{

auto a = 1;

auto b = 1.1;

auto pa = &a;

cout << a << " " << b << " " << *pa << endl;

vector<int> vt = { 1,2,3,4 };

auto it = vt.begin();

while (it != vt.end()) {

cout << *it << " ";

++it;

}

cout << endl;

return 0;

}

decltype

关键字decltype将变量的类型声明为表达式指定的类型。

<code>// decltype的一些使用使用场景

template<class T1, class T2>

void F(T1 t1, T2 t2)

{ -- -->

decltype(t1 * t2) ret;

cout << typeid(ret).name() << endl;

}

int main()

{

const int x = 1;

double y = 2.2;

decltype(x * y) ret; // ret的类型是double

decltype(&x) p; // p的类型是int*

cout << typeid(ret).name() << endl;

cout << typeid(p).name() << endl;

F(1, 'a');

return 0;

}

🔥STL中的一些变化

新容器

以下被框起来的是C++11新增的几容器，实际最有用的还是unordered_map和unordered_set。其中array是静态的数组，forward_list是单链表。

容器中的一些新方法

我们如果打开文档，会发现基本上每个容器都会有一两个标注了C++11的成员函数接口。如cbegin和cend方法返回const迭代器等。

实际上C++11更新后，容器中新增方法最好用的是插入接口函数的右值引用。而右值引用，又是需要学习的一大重点新语法了。

🔥右值引用和移动语义

左值引用和右值引用

传统C++语法中就有引用的语法，而C++11中新增了右值引用语法特性，我们之前了解使用的引用都叫左值引用。不过无论左值引用还是右值引用，都是给对象取别名。

左值引用：给左值取别名。

右值引用：给右值取别名。

<code>// x和y都是左值

double x = 1.1, y = 2.2;

// 以下几个都是常见的右值

10;

x + y;

fmin(x, y);

// 以下几个都是对右值的右值引用

int&& rr1 = 10;

double&& rr2 = x + y;

double&& rr3 = fmin(x, y);

// 这里编译会报错：error C2106: “=”: 左操作数必须为左值

10 = 1;

x + y = 1;

fmin(x, y) = 1;

常见右值：常量，临时对象，匿名对象等。

右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1去引用。

左值引用和右值引用比较

左值引用：

左值引用只能引用左值，不能引用右值。但是const左值引用即可引用左值，也可引用右值。

右值引用：

右值引用只能引用右值，不能引用左值。但是右值引用可以引用move以后的左值。

// 右值引用只能右值，不能引用左值。

int&& r1 = 10;

// error C2440: “初始化”: 无法从“int”转换为“int &&”

int a = 10;

// int&& r2 = a; // message : 无法将左值绑定到右值引用

// 右值引用可以引用move以后的左值

int&& r3 = std::move(a);

int&& r4 = (int&&)a; // 作用和效果与上一行代码等同

// move本质是强转，更底层其实是对右值取地址

// 我们所说的右值无法取地址只是语法层面规定

// 但在编译器看来右值也是有地址的

// 故右值引用可以在底层去取其地址

右值引用的使用场景及意义

意义：减少拷贝。

场景：右值引用传参/引用传返回值（解决C++98尚未解决的问题->构造和传返回值的拷贝消耗）

namespace ForcibleBugMaker

{ -- -->

class string

{

public:

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& tmp)

{

std::swap(_str, tmp._str);

std::swap(_size, tmp._size);

std::swap(_capacity, tmp._capacity);

}

// 拷贝构造

string(const string& s)

:_str(nullptr)

{

cout << "string(const string& s) -- 深拷贝" << endl;

string str(s._str);

swap(str);

}

// 赋值重载

string& operator=(const string& s)

{

cout << "string& operator=(string s) -- 深拷贝" << endl;

string tmp(s);

swap(tmp);

return *this;

}

// 移动构造

string(string&& s)

:_str(nullptr)

, _size(0)

, _capacity(0)

{

cout << "string(string&& s) -- 移动语义" << endl;

swap(s);

}

// 移动赋值

string& operator=(string&& s)

{

cout << "string& operator=(string&& s) -- 移动语义" << endl;

swap(s);

return *this;

}

~string()

{

delete[] _str;

_str = nullptr;

}

private:

char* _str;

size_t _size;

size_t _capacity;

};

}

int main()

{

ForcibleBugMaker::string s1("hello world");

ForcibleBugMaker::string s2(s1); // 调用拷贝构造

ForcibleBugMaker::string s3(ForcibleBugMaker::string("lllllll")); // 调用移动构造，编译器优化开的过大可能会直接构造

ForcibleBugMaker::string s4 = s1; // 调用赋值重载

ForcibleBugMaker::string s5 = std::move(s1); // 调用移动赋值，同时会将s1的资源转移给s5

return 0;

}

左值引用的短板：

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：string my_to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

std::string my_to_string(int value)

{

bool flag = true;

if (value < 0)

{

flag = false;

value = 0 - value;

}

std::string str;

while (value > 0)

{

int x = value % 10;

value /= 10;

str += ('0' + x);

}

if (flag == false)

str += '-';

std::reverse(str.begin(), str.end());

return str;

}

int main()

{

std::string ret1 = my_to_string(1234);

std::string ret2 = my_to_string(-1234);

return 0;

}

但是当std的string中存在移动构造string(string&& s)时，移动构造本质是将参数右值的资源窃取，占为己有，那么就不需要做深拷贝了。上述代码中my_to_string函数内临时变量str的资源会被右值引用带走传递给新构造的ret1对象，从而减少拷贝。同样，移动赋值对此也适用，如例ret2。

模板中的&&万能引用 和 完美转发

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。

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<typename T>

void PerfectForward(T&& t)

{

Fun(t);

}

int main()

{

PerfectForward(10); // 右值

int a;

PerfectForward(a); // 左值

PerfectForward(std::move(a)); // 右值

const int b = 8;

PerfectForward(b); // const 左值

PerfectForward(std::move(b)); // const 右值

return 0;

}

如果你观察结果，会发现并没有任何一个PerfectForward函数调用右值引用的重载。

问：r1的属性是左值还是右值？

<code>std::string&& r1 = std::to_string("1234");

答：r1的属性为左值，只有属性为左值才能够移动资源。

回到刚才的示例，模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发。

std::forward完美转发在传参的过程中保留对象原生类型属性：

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

// std::forward<T>(t)在传参的过程中保持了t的原生类型属性

template<typename T>

void PerfectForward(T&& t)

{

Fun(std::forward<T>(t));

}

int main()

{

PerfectForward(10); // 右值

int a;

PerfectForward(a); // 左值

PerfectForward(std::move(a)); // 右值

const int b = 8;

PerfectForward(b); // const 左值

PerfectForward(std::move(b)); // const 右值

return 0;

}

使用完美转发，就可以成功调用到我们所需要的Fun重载了。

完美转发能保持原生类型的属性这一点非常有用，比如在封装一些容器的时候，正真的资源会被封装好几层，如果没有完美转发，所传递的右值在第一次传递时就会退化成左值，从而导致调用底层的左值引用，就与实际目标不符了。

🌈结语

本篇博客的内容讲的比较杂，从开始对C++11的介绍；到统一的列表初始化{}；能帮助我们推导类型的新增关键字；STL新增的容器；提高效率的右值引用。这些语法也是补了98的一些坑，完善了整个C++语法体系。作为一个C++的大版本，还是非常值得去学习的。