在此之前,我们所用的引用,其实都是左值引用。
int a = 10;
int& ra = a;
下面我们来重新认识一下引用:
而何为左值?左值引用其实是什么?请往下看~
左值是一个表示数据的表达式(如变量名或解引用的指针),我们可以获取它的地址+可以对它赋值,左值可以出现赋值符号的左边,也可以出现在赋值符号的右边。定义时const修饰符后的左 值,不能给它赋值,但是可以取它的地址。左值引用就是给左值的引用,给左值取别名。
例如:
int main()
{
//左值:变量名/解引用的指针
// 以下的p、b、c、*p都是左值
int* p = new int(0); //p是变量名,为左值 *p为解引用的指针
int b = 1; // b为变量名
const int c = 2; //c为变量名。加上const后c的值不能被修改
c = 3;//error
//左值引用:
// 以下几个是对上面左值的左值引用
int*& rp = p; //对p进行引用,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; //表达式返回值,即return x + y;
fmin(x, y); //函数返回值
// 以下几个都是对右值的右值引用
int&& rr1 = 10;
rr1 = 20;//注意这里!
int* prr1 = &rr1; //注意这里!
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错:error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}
从上面的代码我们看到两个神奇的地方!
第一个是在右值引用后,竟然可以对右值引用重新赋值!
第二个是右值是不能取地址的,但是给右值取别名后,这个别名可以被取地址!
这是右值引用的特性!右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,且可以取到该位置的地址,也就是说例如:不能取字面量10的地址,但是rr1引用后,可以对rr1取地址,也可以修改rr1。如果不想rr1被修改,可以用const int&& rr1 去引用!
对于右值,我们可以将其分成两种右值:
第一种是纯右值。所谓纯右值,是内置类型表达式的值。
第二种是将亡值。所谓将亡值,是自定义类型表达式的值。
总结右值引用和左值引用:
基于上述对左值和右值的解析,我们可以总结以下几点:
①左值引用只能引用左值,不能引用右值。这里涉及到了权限的放大。 ②如果加了const修饰的左值引用,可以引用左值和右值。因为有了const修饰,要么是权限的平移,要么是权限的缩小。 ③右值引用只能引用右值,不能引用左值。 ④右值可以引用move后的左值。函数move的作用是让左值变成右值去使用。
int main()
{
// ①左值引用只能引用左值,不能引用右值。
int a = 10;
int& ra1 = a; // ra1为a的别名,左值引用引用左值,a为左值
//int& ra2 = 10; // 编译失败,因为10是右值,左值引用不能引用右值
// ②const左值引用既可引用左值,也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
// ③右值引用只能右值,不能引用左值。
int&& r1 = 10;
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
int&& r2 = a; //a是左值,&&是右值引用,右值引用不能引用左值
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}
左值引用很好,因为左值引用的存在,在函数传参和函数传返回值的时候减少了拷贝,从而提高了效率。但是存在这样一个问题:在一个函数中,如果要使用左值引用作为返回值,那么这个返回的变量的生命周期必须不能随函数的销毁而销毁!
看下面代码:
//函数传参使用左值引用,减少拷贝
template<class T>
void func1(const T& x)
{
}
//函数传返回值,使用左值引用减少拷贝,
//返回的x是传进来的参数,x不会随函数的销毁而销毁。
template<class T>
const T& func2(const T& x)
{
// ...
return x;
}
//ret为函数栈帧中的变量,会随函数的销毁而销毁
//ret做返回值,这种情况下就得进行拷贝
template<class T>
T func3(const T& x)
{
T ret;
// ...
return ret;
}
对于前两种情况,都可以使用左值引用,减少拷贝。但是对于第三种情况,在没有认识到右值引用的时候,它就必须进行拷贝。
这就是左值引用未能解决的场景问题。因此,右值引用的价值之一,就是补齐左值引用的这一个短板。
这里选择复用我们自己模拟实现string类的代码作为测试代码:模拟实现string类
这里将对string类添加右值引用的移动构造和移动赋值!
在此之前,我们先来看看,在没有实现移动构造和移动赋值之前,以下代码的结果如何:
string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
my_string::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()
{
my_string::string ret;
ret = my_string::to_string(-1234);
return 0;
}
结果如下: 在调用to_string的时候,传值传参,调用一次深拷贝。返回值返回的时候,因为没有移动构造,调用就会调用拷贝构造,因为const左值引用可以引用右值,因此会调用深拷贝。赋值给ret的时候也调用了一次深拷贝。
在代码中,-1234是常量,为右值。但是在模拟的string类中,并没有专门右值引用的构造,并且对ret的赋值,也是右值,但是没有右值引用的赋值,只能去调用深拷贝,因为深拷贝的左值引用加了const修饰。
接着我们加入右值引用的移动拷贝和移动构造:
在实现这两个接口前,在上文中提到了右值引用的两种形式:纯右值和将亡值。
我们来看将亡值,从名字中可以看出,这种右值是即将失去生命的值,也就是生命周期快到了,往后的代码程序中不需要它,因此,我们可以利用将亡值进行一次移动构造和移动赋值!
既然都将亡了,那么我就用我的吸星大法,将你的功力吸走!因此,实现的思路就是交换!
// 移动构造
string(string&& s)
{
cout << "string(const string& s) -- 移动拷贝" << endl;
swap(s);
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string s) -- 移动赋值" << endl;
swap(s);
return *this;
}
上述测试代码的结果变成了这样的!
我们自己实现的to_string,在传入-1234作为参数,此时拷贝的是使用移动拷贝,而str作为函数里面的变量,在返回值返回的时候,是作为右值调用移动赋值赋值给ret,减少了拷贝!
整体测试代码如下:
namespace my_string
{
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)
{
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(string&& s)
{
cout << "string(const string& s) -- 移动拷贝" << endl;
swap(s);
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string s) -- 移动赋值" << endl;
swap(s);
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 = nullptr;
size_t _size = 0;
size_t _capacity = 0; // 不包含最后做标识的\0
};
//转化成字符串
string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
my_string::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()
{
my_string::string ret;
ret = my_string::to_string(-1234);
return 0;
}
总结一下右值引用和左值引用对减少拷贝的方式:
右值引用和左值引用减少拷贝的原理不一样。左值引用减少拷贝的方法是起别名,直接起作用,而右值引用减少拷贝的方法是实现移动拷贝和移动赋值,在将亡值的情况下,直接转移资源,间接起作用。
右值引用的价值之二:对于插入一些插入右值数据,也可以减少拷贝!
比如list容器,如果插入接口insert的传值是左值引用,那么在插入右值的时候,由于没有移动拷贝,并且加了const修饰,此时的左值引用可以引用右值,调用的是深拷贝。
而如果使用了移动拷贝,参数为右值引用,那么就会采用移动拷贝,减少了拷贝的次数!
万能引用的意思是不仅可以引用左值也能引用右值。
看下面代码:
// 万能引用
template<typename T>
void PerfectForward(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;
}
加上模板参数后,对于同时存在左值和右值的传参,就不需要写两份接口了。模板参数推演如下:
当传入的是左值,会发生重叠,将两个&变成一个。传入的是右值,那么就不会重叠。
当一个右值通过万能引用或者是右值引用传入到函数后,此时这个右值可以被看成是一个左值了!因为传入后,对于引用右值的变量,开辟了空间,可以被修改,可以取地址!因此,如果传入后,需要对这个值再次用于传参的时候,就被当作是左值了!而如果我们加上move()来把其变成右值,确实可以解决这个问题。但是却让原本就是左值的值通过万能引用后,在通过move变成了右值,这又不符合要求了!两边难。
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); //全是左值
//Fun(move(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;
}
没有用move(),全是左值引用。
使用move(),全是右值。
因此,C++11新增了一个完美转化,可以让编译器自动取识别是左值还是右值。使用C++库中的forward进行转化。
template<typename T>
void PerfectForward(T&& t)
{
//....
Fun(std::forward<T>(t));
}
移动构造和移动赋值被新增到默认成员函数的成员团中。
移动构造函数:
如果你没有自己实现移动构造函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个(注意是全都没有实现的情况!)。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,自定义类型成员,则需要看这个成员是否实现移动构造,如果实现了就调用移动构造,没有实现就调用拷贝构造。
移动赋值:
如果你没有自己实现移动赋值重载函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中 的任意一个(注意也是全都没有实现),那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,自定义类型成员,则需要看这个成员是否实现移动赋值,如果实现了就调用移动赋值,没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)如果你提供了移动构造或者移动赋值,编译器不会自动提供拷贝构造和拷贝赋值。
强制生成默认函数的关键字default:
假设对于移动构造函数,我们实现了析构函数、拷贝构造和拷贝赋值重载其中一个,但是也需要用到默认移动构造函数,那么我们可以强制让其生成默认移动构造函数!
使用关键字default。使用例子如下:
实现一个Person类,实现一个拷贝构造,此时Person类就不可以生成默认移动构造和移动赋值了,其成员变量_name和_age也就不能去调用自己的移动构造等函数。
但是我们让其强制生成,之后成员变量中的_name和_age就会去调用自己的移动构造。
class Person
{
public:
//构造函数
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
//拷贝构造,写了这个函数后不能默认生成移动构造和移动赋值
Person(const Person& p)
:_name(p._name)
, _age(p._age)
{}
//使用关键字default强制生成默认移动构造
Person(Person&& p) = default;
private:
string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1); //强制生成后,成员变量中的_name和_age就会去调用自己的移动构造或拷贝构造
return 0;
}
禁止生成默认函数的关键字delete
如果能想要限制某些默认函数的生成,在C++98中,是该函数设置成private,并且只声明补丁已,这样只要其他人想要调用就会报错。在C++11中更简单,只需在该函数声明加上=delete即可,该语法指示编译器不生成对应函数的默认版本,称=delete修饰的函数为删除函数。
Person(const Person& p) = delete;