文章目录
- 一、左值引用、 右值引用
- 1.1 左值与右值
- 1.2 左值引用
- 1.3 右值引用
- 二、右值引用的意义
- 三、移动语句
- 3.1 移动构造
- 3.2 移动赋值
- 3.3 总结
- 四、move问题
- 五、完美转发
- 5.1 万能引用与折叠
- 5.2 完美转发std::forward
一、左值引用、 右值引用
1.1 左值与右值
我们经常能听到左值和右值，那么我们怎么判断左值和右值呢？
C++中还有一个被广泛认同的说法， 那就是可以取地址的、 有名字的就是左值， 反之，不能取地址的、 没有名字的就是右值。
左值可以出现在左边和右边，而右值不能出现在左边。
举个例子：
a是个左值a+b就是个右值
因为可以对a取地址：&a
但是不能对a + b取地址：&(a + b)
左值和右值不是个变量，而是个数据表达式。
左值一般有：变量名或解引用的指针
右值一般有：字面常量、表达式返回值，函数返回值
1.2 左值引用
左值引用就是给左值起别名。
int main()
{
// 左值
int a = 0;
int* b = nullptr;
const int c = 1;
const int* d = nullptr;
// 左值引用
int& ra = a;
int*& rb = b;
const int& rc = c;
const int*& rd = d;
// 左值引用不能引用右值，但const左值引用可以
//int& e = 10;
//int& f = (a + c);
const int& e = 10;
const int& f = (a + c);
return 0;
}
1.3 右值引用
右值引用只能引用右值，不能引用左值。
但是右值引用可以move以后的左值，move可以把ret变成一个将亡值(右值)。
int main()
{
// 只能引用右值
int&& a = 10;
a++;// 右值引用后变左值
int ret = 0;
//int&& b = ret;// 不能引用左值
// 可以引用move后的左值
int&& b = std::move(ret);
return 0;
}
const引用既可以引用左值也可以引用右值。
二、右值引用的意义
我们以前使用的引用基本上都是左值引用（函数传参，函数传返回值），左值引用的作用主要用来减少拷贝。
但是左值引用并没有彻底的解决：传返回值的时候，如果是一个局部变量，我们就无法引用返回了。
template <class T>
T& fun()
{
T a;
return a;
}
这里出了作用域后对象自动销毁，所以不能传递回去造成越界访问。
为了解决这种情况，我们就需要右值引用，接下来用我们之前写过的string类举例子，方便观察。
namespace yyh
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
_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)
{
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)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
string Get()
{
string s = "123456";
return s;
}
}
int main()
{
yyh::string ret = yyh::Get();
return 0;
}
这里本来应该是Get返回的时候先拷贝一个临时对象，再用这个临时对象拷贝给ret，但是编译器经过优化可以直接拷贝给ret，只调用一次拷贝构造。
不经过优化：
如果对象较小就放到寄存器，如果较大就在两个栈帧之间创建一个栈帧压返回值。
但是就算经过了优化也还是要拷贝，如果要返回的对象非常大，就会有大消耗。
三、移动语句
3.1 移动构造
右值又分为纯右值和将亡值
纯右值：内置类型的表达式的值。
将亡值：自定义类型表达式的值。
对于一个将亡值，与其让它消失，还不如直接把它的值交换走，换给有需要的对象。
所以我们可以写一个拷贝构造的重载。
// 拷贝构造
string(const string& s)
{
cout << "string(const string& s) -- 深拷贝" << endl;
string tmp(s._str);
swap(tmp);
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动拷贝" << endl;
swap(s);
}
这里如果是左值就会匹配拷贝构造，如果是右值就会匹配移动构造。
结果：
3.2 移动赋值
上边解决了拷贝的问题，接下来解决赋值问题。
这里会调用string(const string& s)是因为operator=使用的是现代写法。
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string& s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
3.3 总结
左值引用和右值引用减少拷贝的方式不太一样。
左值引用是直接取别名。
右值引用是使用移动构造和移动拷贝间接实现，可以把要返回的临时对象看作将亡值，进行资源转移。
右值引用主要解决的是对象传值返回拷贝问题。也可以解决容器插入数据的拷贝问题（如果插入的是右值就不需要深拷贝）。
四、move问题
我们知道move可以把一个左值变成右值，但是有可能会出现问题
int main()
{
yyh::string s1("aaaaa");
yyh::string s2(std::move(s1));
return 0;
}
移动构造把资源转移后原来的对象的资源就消失了。
void fun2(int&& i)
{
cout << "fun2(int&& i)" << endl;
}
void fun2(int& i)
{
cout << "fun2(int& i)" << endl;
}
void fun1(int&& i)
{
cout << "fun1(int&& i)" << endl;
fun2(i);
}
int main()
{
fun1(1);
return 0;
}
这里为什么在fun1函数中没有调用void fun2(int&& i)呢？
因为右值引用后就会变成左值，而左值就会对应调用void fun2(int& i)。
如果我们想让fun1调用void fun2(int&& i)：
void fun1(int&& i)
{
cout << "fun1(int&& i)" << endl;
fun2(std::move(i));
}
但是如果有多层嵌套函数就会频繁使用move，所以C++11引入新语法完美转发std::forward
五、完美转发
5.1 万能引用与折叠
上面我们区分左值和右值是通过两个函数的参数来区分。
在普通函数里右值不能引用左值：
void fun1(int&& i)
{
cout << "fun1(int&& i)" << endl;
}
int main()
{
int a = 1;
//fun1(a);// 右值不能引用左值
return 0;
}
所以C++11提供了万能引用：
// 万能引用
template <class T>
void fun(T&& i)
{
cout << "fun(int& i)" << endl;
}
int main()
{
int a = 1;
fun(a);// 左值
fun(std::move(a));// 右值
const int b = 1;
fun(b);// const左值
fun(std::move(b));// const右值
return 0;
}
这样就可以既引用左值/const左值 也可以引用右值/const右值。
完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。
实例化出以下类型的不同函数：
5.2 完美转发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; }
// 万能引用
template <class T>
void fun(T&& i)
{
Fun(i);
}
int main()
{
int a = 1;
fun(a);// 左值
fun(std::move(a));// 右值
const int b = 1;
fun(b);// const左值
fun(std::move(b));// const右值
return 0;
}
我们可以看出这个fun函数把所有的全部转化为左值，不是我们想要的。
所以就有了完美转发std::forward
完美转发适用于这样的场景： 需要将一组参数原封不动的传递给另一个函数。 而且原封不动传递的不仅仅是参数的数值，还包括：左值/右值，const/非const这些性质。
// 万能引用
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 <class T>
void fun(T&& i)
{
// 完美转发，保持原本属性
Fun(std::forward<T>(i));
}
int main()
{
int a = 1;
fun(a);// 左值
fun(std::move(a));// 右值
const int b = 1;
fun(b);// const左值
fun(std::move(b));// const右值
return 0;
}
