文章目录
- 1 右值引用和移动语义
- 1.1 左值引用和右值引用
- 1.2 右值引用的使用场景
- 1.3 新的类功能
- 2 万能引用与完美转发
- 2.1 万能引用的基本介绍和使用
- 2.2 完美转发
- 2.3 完美转发的实际应用场景
- 3 可变参数模板
- 3.1基本语法
- 3.2递归函数方式展开参数包
- 3.3逗号表达式展开参数包
- 3.4 可变参数模板的应用
1 右值引用和移动语义
1.1 左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
在讲解右值引用之前我们来回答一下什么是左值 ❓什么是右值 ❓
❗️❗️❗️ 左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值。右值不能取地址+不能赋值。
左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
比如：
int main()
{
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
用法：
int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;
min(x, y);
// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
min(x, y) = 1;
return 0;
}
需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。
int main()
{
double x = 1.1, y = 2.2;
int&& rr1 = 10;
const double&& rr2 = x + y;
rr1 = 20;
rr2 = 5.5; // 报错
return 0;
}
💯左值引用和右值引用的总结:💯
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
3. 右值引用只能右值，不能引用左值。
4. 但是右值引用可以move以后的左值
😄验证:😄
int main()
{
// 左值引用只能引用左值，不能引用右值。
int a = 10;
int& ra1 = a; // ra为a的别名
int& ra2 = 10; // 编译失败，因为10是右值
// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
return 0;
}
int main()
{
// 右值引用只能右值，不能引用左值。
int&& r1 = 10;
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
int&& r2 = a;
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}
但是要注意右值引用引用左值及其一些更深入的使用场景分析。
比如下面这种场景：
int main()
{
string s1("hello world");
string s2(s1);
string s3(std::move(s1));
return 0;
}
我们调试起来看：
我们发现执行了string s3(std::move(s1))后s1的被置空了，这个我们后面会着重讲解，叫做资源转移现象。所以使用move函数时大家一定要特别注意。
1.2 右值引用的使用场景
像我们上面讲解的应用场景实际中我们并不会这么简单的应用。前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢❓是不是化蛇添足呢❓下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！
grm::string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
grm::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;
}
我们来看看上面的代码：通过左值引用我们可以减少拷贝优化效率，但是上面这种情况我们在to_string函数的内部定义了一个局部对象str,从左值引用的角度我们已经不能在做出优化了，因为你不能返回一个局部对象来用引用接收。有人或许又想到了另外一种方法：那我们返回 grm::string&& 不就行了吗？
大家想想这种方式可行吗？依旧是不行的，因为str是临时变量，出了作用域是要被销毁的，你拿引用接受不就是在访问一个不属于你的空间吗？
我们可以用下面这种方式来延长临时对象的生命周期：
const grm::string& s1 = grm::to_string(1234);
注意：这种方式是将局部对象拷贝给了临时对象，通过const&的方式延长临时对象的生命周期，并不是延长了局部对象的生命周期。
除了上面的方法外，那我们应该怎样优化呢❓
在C++中右值被分为纯右值和将亡值。纯右值指的是我们前面举的例子像一些常数啥的。而将亡值顾名思义，就是该值即将死亡。我们发现其实上面代码中的str其实就是一个将亡值。那我们如果要在外面用一个string来接受to_string后的数据，不妨直接转移str的资源到外部变量即可。
而这种资源转移的方式我们称为移动语义。
那我们应该怎样实现资源转移呢？
我们不妨借用下当初自己模拟实现string的代码：
namespace grm
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
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);
}
// s1.swap(s2)
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;
string tmp(s._str);
swap(tmp);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
~string()
{
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];
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)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
我们给出下面的测试程序：
int main()
{
grm::string ret1 = grm::to_string(1234);
return 0;
}
不加上移动构造和移动赋值前，结果是什么呢❓
如果编译器没有做出优化，那么将会是两次拷贝构造，编译器做了优化后将从两次拷贝构造优化成一次拷贝构造。如果对于这里没有理解的老哥可以移步博主的另外一篇文章：【类和对象中的编译器优化】
但是我们不妨增加一个移动构造的版本：
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动语义" << endl;
swap(s);
}
这样我们再次运行时：
这样资源转移后我们就不用再担心深拷贝的代价问题了，直接将将亡值的资源转移给我接受。
这里同样是有编译器的优化的，先应该是将局部对象str的资源先转移给临时对象，然后再将临时对象的资源转移给ret1。这里编译器将两次移动构造优化成了一次移动构造。
当我们不实现移动赋值时，写下面的测试代码，大家能够分析出打印结果吗❓
int main()
{
grm::string ret1;
ret1= grm::to_string(1234);
return 0;
}
我们可以知道：将局部对象的资源转移给了临时对象，然后将临时对象拷贝赋值给ret1,但是为啥这里打印了拷贝构造和拷贝赋值啊？别忘了，我们用的是现代写法：拷贝赋值是借助拷贝构造实现的。
那当我们实现了移动赋值后呢？
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
我们再次运行：
这里依旧是先将局部对象str的资源先转移给临时对象，然后再转移给ret1。
C++11后，STL的所有容器都增加了右值引用的版本：
STL容器中，在insert等成员方法中也增加了右值引用：
其实也很好理解，当我们插入一个临时对象（接就是将亡值的时候)会直接调用右值引用的版本将将亡值的资源给转移走。
所以我们可以总结出：其实左值引用和右值引用本质上都是减少拷贝，提高效率。但是他们出发的角度不同：左值引用是直接从拷贝出发的，右值引用是可以转移一些将亡值的资源。
有些书上面写着，右值引用可以延长对象的生命周期，其实我觉得不太准确，因为对象的生命周期其实并没有延长，延长的是对象里面资源的生命周期。
1.3 新的类功能
原来C++类中，有6个默认成员函数：
- 构造函数
- 析构函数
- 拷贝构造函数
- 拷贝赋值重载
- 取地址重载
- const 取地址重载
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
- 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
- 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
- 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
如果大家想强制生成默认函数可以用default关键字，强制不生成默认函数可以用关键字delete
2 万能引用与完美转发
2.1 万能引用的基本介绍和使用
首先我们先来看看下面的代码：
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);
PerfectForward(std::move(b));
return 0;
}
我们来看看运行结果：
怎么结果全是左值引用呀❓我们不是也引用了右值的吗❓
其实模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。(有些地方也叫做引用折叠)但是在后续使用中都退化成了左值。
所以我们刚才看见的打印的全部是左值。
假如我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发。
2.2 完美转发
std::forward<T>(t) //在传参的过程中保持了t的原生类型属性。
比如上面的代码我们可以改为：
void PerfectForward(T&& t)
{
Fun(forward<T>(t));
}
当我们再次运行时：
这样就保留了上层传入对象的类型。
2.3 完美转发的实际应用场景
我们可以借用下当初模拟实现list的那部分代码：凡是向下传的参数都得forward,
namespace grm
{
template<class T>
struct ListNode
{
ListNode* _next = nullptr;
ListNode* _prev = nullptr;
T _data;
ListNode(const T& data=T())
:_next(nullptr)
,_prev(nullptr)
,_data(data)
{}
ListNode(T&& data )
:_next(nullptr)
, _prev(nullptr)
, _data(std::forward<T>(data))
{}
};
template<class T>
class List
{
typedef ListNode<T> Node;
public:
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(T&& x)
{
//Insert(_head, x);
Insert(_head, std::forward<T>(x));
}
void PushFront(T&& x)
{
//Insert(_head->_next, x);
Insert(_head->_next, std::forward<T>(x));
}
void Insert(Node* pos, T&& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node(std::forward<T>(x));
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = pos;
pos->_prev = newnode;
}
void Insert(Node* pos, const T& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node(x);
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = pos;
pos->_prev = newnode;
}
private:
Node* _head;
};
}
int main()
{
grm::List<grm::string> lt;
lt.PushBack("1111");
lt.PushFront("2222");
return 0;
}
注意上面代码是在模拟实现list的基础上改编了一下，否则太长了不太好看。不过总体思路都是一样的，凡是我们向下传的参数都得完美转发一下。
3 可变参数模板
3.1基本语法
C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止，以后大家如果有需要，再可以深入学习。
下面就是一个基本可变参数的函数模板：
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。
3.2递归函数方式展开参数包
// 递归终止函数
template <class T>
void ShowList(const T& t)
{
cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
cout << value <<" ";
ShowList(args...);
}
int main()
{
ShowList(1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}
我们如果想打印参数包大小语法形式是这样的：cout << sizeof...(args) << endl;
3.3逗号表达式展开参数包
template <class T>
void PrintArg(T t)
{
cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (PrintArg(args), 0)... };
cout << endl;
}
int main()
{
ShowList(1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
3.4 可变参数模板的应用
那究竟STL在哪些地方用到了可变参数模板呢？
首先我们来看看C++11系列提供的emplace系列。
我以vector为例：
网上有人说使用emplace_back系列的效率是高于push_back系列的，但是其实这种说法是不够全面的，我们下面来分析分析：
如果插入的数据是有资源的右值(比如插入了一个string的匿名对象),调用push_back的话是一次构造+移动构造，调用emplace_back的话直接是一次构造，总的来说差别不大。但是如果插入的像日期类的对象，调用push_back的话是一次构造+拷贝构造，调用emplace_back的话直接是一次构造，这样来看效率的确会高一些。所以我们得分情况讨论。
不仅在emplace系列，在C++11提供的线程库中对可变参数模板也有应用，我们先来简单的看看，具体的讲解我将会在讲解线程库的博文中讲解。
好了，今天的讲解就到这里了，如果觉得该文章对你有帮助的话能不能3连支持一下。😘😘😘
