在此之前，我们所用的引用，其实都是左值引用。

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的时候也调用了一次深拷贝。

8C]0T@L9K$_WVMLAL5FSGOY.png

在代码中，-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;
    }

上述测试代码的结果变成了这样的！

(IRS5R4H1~`I]9YM_HQ%MDS.png

我们自己实现的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修饰，此时的左值引用可以引用右值，调用的是深拷贝。

NU4S4~RQ{D2[R~KKBBGBI9Y.png

而如果使用了移动拷贝，参数为右值引用，那么就会采用移动拷贝，减少了拷贝的次数！

IW_5G3DF_U)M5TR@UGNKRTT.png

万能引用和完美转发

万能引用

万能引用的意思是不仅可以引用左值也能引用右值。

看下面代码：

// 万能引用
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;
}

加上模板参数后，对于同时存在左值和右值的传参，就不需要写两份接口了。模板参数推演如下：

P_3O9GYNBP}ET@MYLCCUSTO.png

当传入的是左值，会发生重叠，将两个&变成一个。传入的是右值，那么就不会重叠。

完美转发

当一个右值通过万能引用或者是右值引用传入到函数后，此时这个右值可以被看成是一个左值了！因为传入后，对于引用右值的变量，开辟了空间，可以被修改，可以取地址！因此，如果传入后，需要对这个值再次用于传参的时候，就被当作是左值了！而如果我们加上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(),全是左值引用。

PZ0V_X10`%DYRLXEL~FE@J5.png

使用move()，全是右值。

$_Y]$`_1%]F~{ELX61~Y8TIQ.png$

因此，C++11新增了一个完美转化，可以让编译器自动取识别是左值还是右值。使用C++库中的forward进行转化。

template<typename T>
void PerfectForward(T&& t)
{
  //....
  Fun(std::forward<T>(t));
}

FV23{AR]7$A$3ZJ89B6D}RO.png

两个新增的默认成员函数

移动构造和移动赋值被新增到默认成员函数的成员团中。

移动构造函数：

如果你没有自己实现移动构造函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个（注意是全都没有实现的情况！）。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

移动赋值：

如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中
的任意一个（注意也是全都没有实现），那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

对于默认函数，我们这里可以补充一点知识：

强制生成默认函数的关键字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;

C++右值引用/移动语义

右值引用的作用和意义

万能引用和完美转发

万能引用

完美转发

两个新增的默认成员函数

对于默认函数，我们这里可以补充一点知识：

热门文章

最新文章

相关课程

相关电子书