C++11 ---- 右值引用和移动语义
文章目录
- 1 左值引用和右值引用
- 2. 左值引用与右值引用总结
- 3. 右值引用使用场景和意义
- 4. 再谈移动构造函数和移动赋值运算符重载
- 5. 关键字default 和 delete
- 6. move函数
- 7. 完美转发
1 左值引用和右值引用
之前的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以在C++11之前的引用都叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
那什么是左值？什么是左值引用呢？
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋
值，左值可以出现赋值符号的左边，也可以出现在赋值符号的右边。(定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。)左值引用就是给左值的引用，给左值取别名。
int main()
{
//a pb c *pb都是左值 -- 表达数据的表达式
int a = 10;
int* pb = new int(20);
const int c = 30;
//以下是对上面左值的引用
int& ra = a;
int*& rpb = pb;
const int& rc = c;
int& rb = *pb;
return 0;
}
那什么是右值？什么是右值引用？
右值也是一个表示数据的表达式(如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等)，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。右值引用是两个&&符号。
int add(int a, int b)
{
return a + b;
}
int main()
{
int a = 1, b = 2;
// 以下几个都是常见的右值
10;//字面长量
a + b;//表达式的值
add(a, b);//函数返回值
// 以下几个都是对右值的右值引用
int&& r1 = 10;
int&& r2 = a + b;
int&& r3 = add(a, b);
// 下面代码编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
a + b = 1;
add(a, b) = 1;
return 0;
}
ps:右值是不能取地址的，但是右值被引用以后，会导致右值被存储到特定位置，且可以取到该位置的地址。
例如：不能取字面量10的地址，但是10被r1引用后，可以对r1取地址，也可以修改rr1。
如果不想r1被修改，可以用const int&& r1 去引用，这个了解一下就行，不重要。
2. 左值引用与右值引用总结
- 左值引用只能引用左值，不能引用右值。
- 但是const左值引用既可引用左值，也可引用右值。
int main()
{
//int& r1 = 10;//左值引用不能引用右值
//const 左值引用可以引用右值
const int& r1 = 10;
cout << &r1 << " : " << r1 << endl;
return 0;
}
- 右值引用只能右值，不能引用左值。
- 但是右值引用可以move以后的左值。
int main()
{
int a = 10;
//int&& ra = a;//右值引用不能引用左值
int&& ra = move(a);//右值引用可以引用move后的左值
cout << ra << endl;
return 0;
}
3. 右值引用使用场景和意义
在C++11之前，我们平常用到的引用都是左值引用，左值引用在做参数和返回值的场景下可以减少拷贝，提高效率。但是左值引用也是存在它的短板的，当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。
比如我们要实现一个整型转字符串的函数to_string():
namespace zzb
{
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;
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = 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
};
//整型转字符串
zzb::string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
zzb::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;
}
}
在zzb::string to_string(int value)函数中可以看到，由于zzb::string str是个局部的string对象，出了作用域对象就销毁了，因此这里只能使用传值返回，然而传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
int main()
{
zzb::string ret1 = zzb::to_string(1234);
return 0;
}
因此为了解决上述问题，C++11增加了右值引用和移动语义。为了利用移动语义，需要在类中定义移动构造函数。移动构造函数：用于从另一个对象"移动"资源，而不是拷贝资源，因此就不用做深拷贝了。
例如在zzb::string中增加移动构造函数：
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动语义" << endl;
swap(s);
}
我们再运行上面zzb::to_string的调用:
我们会发现，这里没有调用深拷贝的拷贝构造，而是调用了移动构造，这是因为编译器将str识别为了将亡值。上面我们知道C++中的值类别分别为左值和右值，而C++中的右值又分为纯右值和将亡值。纯右值包括表达式的值，字面常量等，而将亡值表示一个即将销毁的对象。因为编译器将str识别为了将亡值，也就意味着，str是个右值，当我们没提供移动构造函数时，编译器会调用深拷贝的拷贝构造，这是因为string(const string& s) 函数参数是const左值引用，而是const左值引用可以引用右值；当我们供移动构造函数时string(string&& s)，有了更匹配的函数，编译器就会调用更匹配 的移动构造函数，而移动构造中没有新开空间，拷贝数据，只是转移了资源，所以效率提高了。
如果我们这样调用zzb::to_string:
int main()
{
zzb::string ret1;
ret1 = zzb::to_string(1234);
return 0;
}
我们会发现又有深拷贝了，发生在赋值的时候：
因此，不仅有移动构造，还有移动赋值，例如在zzb::string中增加移动赋值函数：
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
我们再运行上面zzb::to_string的调用:
这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。zzb::to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为zzb::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。
还需要注意的一点是STL容器插入接口函数也增加了右值引用版本。
4. 再谈移动构造函数和移动赋值运算符重载
原来C++类中，有6个默认成员函数：构造函数、拷贝构造函数、运算符重载、析构函数、普通对象以及const队对象取地址重载。
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。
在C++11中又新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
1.如果你自己没有实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
2.如果你自己没有实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如下面这个例子：
class Student
{
public:
Student(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
private:
zzb::string _name;
int _age;
};
int main()
{
Student s1;
Student s2 = s1;
Student s3 = std::move(s1);
Student s4;
s4 = std::move(s2);
return 0;
}
3.如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
5. 关键字default 和 delete
1. default是用来强制生成默认函数的关键字，假设我们要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。
比如：我们提供了拷贝构造，就不会提供默认构造了。
class Student
{
public:
Student(const Student& s)
:_name(s._name)
,_age(s._age)
{}
private:
zzb::string _name;
int _age;
};
int main()
{
Student s1;
return 0;
}
因此，我们可以使用default关键字显示指定默认构造生成。
Student() = default;
2. delete是禁止生成默认函数的关键字，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
比如我们不想一个类被拷贝，即可用delete修饰拷贝构造函数即可。
Student(const Student& s) = delete;
6. move函数
当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
return ((typename remove_reference<_Ty>::type&&)_Arg);
}
左值经过move处理以后, 会被当成右值，例如下面代码：
int main()
{
zzb::string s1("hello world");
// 这里s1是左值，调用的是拷贝构造
zzb::string s2(s1);
// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
zzb::string s3(std::move(s1));
return 0;
}
7. 完美转发
模板中的&& 万能引用：当函数模板中出现&&不代表表右值引用，而是万能引用，其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。
例如下面代码：
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(0); // 右值
int a = 0;
PerfectForward(a); // 左值
PerfectForward(move(a)); // 右值
const int b = 0;
PerfectForward(b); // const 左值
PerfectForward(move(b)); // const 右值
return 0;
}
我们执行上面代码，可以发现输出的都是左值引用：
这是因为右值引用在后续的使用过程中退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用到完美转发。
forward<T>(t)//在传参的过程中保持了t的原生类型属性。
完美转发在传参的过程中保留对象原生类型属性。
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(forward<T>(t));
}
int main()
{
PerfectForward(0); // 右值
int a = 0;
PerfectForward(a); // 左值
PerfectForward(move(a)); // 右值
const int b = 0;
PerfectForward(b); // const 左值
PerfectForward(move(b)); // const 右值
return 0;
}
至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。
创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！
如果本篇博客有任何错误，请批评指教，不胜感激 ！！！
