非常量引用的初始值必须为左值

今天碰到了这个问题，回顾一下概念：

左值与右值

根据C++Primer第五版，当一个对象被用作右值的时候，用的是对象的值，当对象被用作左值的时候，用的是对象的身份；

下面这个函数就是正确的

#include<iostream>

int function(int a)
{
  return a;
}

int main()
{
  int a = 5;
  function(a);         
  function(1);
}

而这个就是错误的 

#include<iostream>

int function(int &a)
{
  return a;
}

int main()
{
  int a = 5;
  function(a);           
  function(1);//这一句会报错
}

报错如下：

无法将参数1从Int转换为“int &”，非常量引用的初始值必须为左值

这里的左值，可以理解为在内存中有具体的地址的变量，而不是一个短暂的临时变量。

这个左右，可以理解为，在赋值号“=” 的左边，为左值，在等号右边，为右值，但这个左右并不是绝对的。

在第一个例子里，function(int a)的参数为实参，如果传入一个1，函数会创建一个有地址的局部变量a，对a进行赋值，让 a= 1，这里的a是一个左值，所以程序能正确运行，但在第二个例子里，function(int &a)的参数为一个地址，function会根据这个地址去取对应的值，但是我们传入的参数是数字1，这个1显然不是左值，因为它不是变量，没有地址，function根据地址找不到对应的变量，自然会报错。

如果单纯想知道报错是为什么原因，那么看到这里就OK了，如果想继续了解左值、左值引用与右值引用可以接着往下看

---

OK，在了解了左值和右值的概念后，下面来做一组判断，下面代码一共有五个等号，分别判断等号两边的是左值还是右值：

int a = 10;
int c = a;
std::string s1 = "Hello";
std::string s2 = "World";
std::string s3 = s1 + s2;

从等号的左边到右边的答案依次是：

int a = 10; // a左值，10右值
int c = a;  // c左值，a左值
std::string s1 = "Hello"; // s1左值，"Hello"右值
std::string s2 = "World"; // s2左值，"World"右值
std::string s3 = s1 + s2; // s3左值，s1 + s2右值

值得注意的是第二行和第五行，int c = a，由于两边都是变量，都有其存储空间，所以都是左值

但是第五行里，s1和s2都是左值，都有其存储空间，但是s1 + s2就不是左值了，因为相加得到的结果是一个临时变量，会被赋给s3。

左值引用与右值引用

左值引用，顾名思义就是对左值变量的引用，右值引用同理

int &a = 10; // 报错，因为无法创建一个左值的引用指向一个右值

int& GetValue(int& n)
{
    return 10; // 报错，返回的不是左值引用
}


int& GetValue(int& n)
{
    static int a = 10;
    return a; // 正确，a是左值，返回的是左值引用
}

注意，通过关键字const，我们可以实现如下的功能：

const int &a = 10; //正确

这一行代码实际上相当于，这也就是const特殊的地方：

int temp = 10;
const int &a = temp;

所以说，如果对于之前的例子，我们可以通过const关键字让程序正常运行：

#include<iostream>

int function(const int &a)
{
  return a;
}

int main()
{
  int a = 5;
  function(a);           
  function(1); // 这一句不会再报错，能正常运行
}

---

为什么Const有这些作用
评论区有同学问到这个问题，所以补充一下：

上面展示的例子里，const关键字的奇异之处表现在了两个地方：

1. int& r = 0是失败的，而const int&r = 0是OK的

2. 函数的参数若为const T&，则函数可以接受T类型的左值和右值，而函数参数若为T&，则只可以接受T类型的左值



两个问题本质是一样的，核心在于，一个非const的左值引用是不能绑定到右值上的，而一个const类型的左值引用是可以绑定到右值上的

这里提出两个问题：

1. 为什么const的左值引用可以绑定到右值上？

2. 右值的类型是T&&，而const T&的类型与T&&显然不同，这一过程是否发生了隐式转换？

首先说第一个问题：

原因是，这是C++的语言特性（感觉是废话），但C++确实就是这么设计的，C++规定，当使用const引用，绑定到一个右值时，那么该右值在stack上的生命期会被延长，这样做，可以提高性能，也会更方便。


具体的可以看下面这两个例子:

// 例一：比如说我要创建一个int型引用，它引用的int的值是5

// 写法一: 如果const&不可以接受右值, 那么要写两行代码
int a = 5;    // a其实是无用的
int& b = a;

// 写法二: 如果const&可以接受右值, 那么只需要一行代码
const int& c = 5;


// 例二: 写一个函数返回一个两个string的相加
// 写法一
const string& AddStr1(string s1, string s2)
{
    return s1 + s2;
}

// 写法二
string& AddStr2(string s1, string s2)
{
    return s1 + s2;// 这一行会编译报错，因为s1+s2是右值, 而string&是对左值的引用
}

// 写法三
string AddStr3(string s1, string s2)
{
    return s1 + s2;
}

int main(){
    const string& s1 = AddStr1("Hello", "world");// 成功
    string s2& = AddStr2("Hello", "world");// 编译失败
    string s3 = AddStr3("Hello", "world");// 成功，但是有多余的拷贝
}

注意：为了避免问题更复杂，后面的AddStr的参数我没有写const string&，而是直接写的string

总之上面的两个例子，第一个例子是指的这么设计const，可以方便我们写代码，第二个例子是指的这么设计const，能够提高性能

最后解决一下第二个问题，这个问题在C++Primer(5th)上说的比较清楚：const T& 和 T&&，完全是两个类型，但是T&&允许被隐式转换为const T&，也就是说，当函数接受的实参是右值时，编译器会优先去匹配函数形参为T&&的函数，如果没有找到对应的函数，才会去适配函数形参为const T&的函数