C++深入探究引用的使用

一. 引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

类型& 引用变量名(对象名) = 引用实体；

如下：

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("％p\n", &a);
    printf("％p\n", &ra);
}

注意：引用类型必须和引用实体是同种类型的

二. 引用特性

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

如下：

void TestRef()
{
    int a = 10;
    int a2 = 20;
    //a的多个引用
    int& b = a;
    int& c = a;
    int& d = b;
    int& ra;//该条语句编译时会出错，未初始化
    int &ra = a2;//报错，引用了其他实体
    printf("％p ％p ％p ％p\n", &a, &b, &c, &d);
}

三. 常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a; // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
    //int& c = 100; // 该语句编译时会出错，常量是只读的
    const int& c = 100;
}

注意：

引用取别名原则：对原引用变量，读写权限只能缩小，不能放大

const int a = 10;

int& ra = a;

编译不通过，因为放大了权限，原引用本来是只读，但是引用以后却变成了可读可写

int& b = 10;

const int& b = 10;

编译可以通过，因为缩小了权限，原引用本来是可读可写，引用后变成了只读

double d = 12.34;

int& rd = d;

编译不通过，这里比较特殊，看起来是因为类型不同而报错，其实不然，报错是因为权限放大了，为什么？

int类型要引用double类型，double类型转化到int类型属于隐式类型转换会舍弃小数位，隐式类型转换会产生临时变量，double类型到int类型会创建一个临时变量存储double变成了int类型的值，这里需要注意，这个临时变量具有常性是只读的，rd其实是引用了这个临时变量，因为临时变量是只读的，引用了临时变量的rd也应该是只读的，所以这就是为什么const int& rd = d 可以编译通过。

int& c = 100;

编译通过，因为常量本来就是只读的，不加const代表引用后变成了可读可写，权限放大。

四. 使用场景

1. 做参数

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

• 输出型参数

• 减少拷贝，提高效率

2. 做返回值

int& Count()
{
    static int n = 0；
    n++;
    // ...
    return n;
}

减少拷贝

（传值返回需要拷贝数据，传引用返回直接返回变量的别名）

3. 做返回值需要注意的问题

首先，我们要知道当函数返回一个值时，会生成一个临时变量，而函数的返回类型就是这个临时变量的类型

int Add(int a, int b)
{
   return a + b;
}
int Count()
{
   static int n = 0；
   n++;
   return n;
}
int main()
{
   int temp = Add(2, 3);
   int tmp = Count();
   return 0;
}

以上代码将a+b（n）的值赋值给临时变量，临时变量再赋值给temp（tmp），为什么要设置这个临时变量？

其实很简单，在这个代码里是会有问题的，出了函数作用域a+b的值就已经被销毁了，需要一个临时变量去储存这个返回值，再去访问那块空间是非法的，而被static修饰的n由于它的生命周期变长了，即使出了函数也不会被销毁

那么问题来了，以下代码是正确的吗？

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    return 0;
}

很明显是有问题的！这里将c的引用返回 ，而一旦出了函数c就被销毁了，这块空间也 * 作系统收回，再将c的引用赋值给ret就变成了非法访问了，就变成了由引用造成的野指针

由上面的问题可以衍生出以下代码：

这里的ret是什么？

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :"<< ret <<endl;
    return 0;
}

很明显是7，ret是c的引用，由于出了函数以后这块空间的使用权还给了操作系统，由于第二次函数调用仍然是在第一次函数调用的空间进行栈帧的建立，因为ret的地址（ret的地址就是之前那块临时变量的地址）还是之前那个地址，所以由于第二次返回c时建立的临时变量已经变成了7，所以ret也变成了7

但是一定会是7吗？其实不然，我们知道这块空间的使用权还给了操作系统，这块空间也有可能会被其他程序使用了，导致数值变成了不确定性，因为这里是直接马上又调用了这个函数，所以会是7，所以，其实正确答案应该是随机值才对

看下面这个代码就是典型的例子：

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :"<< ret <<endl;
    cout << "Add(1, 2) is :"<< ret <<endl;
    return 0;
}

这里的输出语句其实也是调用了函数，由上面可知第一个是7，那么第二个呢？随机值！因为进行了第一次输出后其实也是进行了函数调用，函数调用会建立栈帧，在上一个输出建立的栈帧处重新建立了栈帧，函数调用前需要先传参，由于上一个输出语句销毁完栈帧以后ret地址处的值被覆盖成随机值，在第二次输出语句中此时就会把这个随机值作为参数传过去给函数，导致输出了随机值，所以传引用返回不是所有情况都可以使用的，像一开始加上了static关键字之类的才可以返回，因为n的生命周期变长了，出了函数作用域没有被销毁，取值都是去静态区取数据。

结论：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

五. 传值传引用效率对比

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

1. 值和引用传参时的效率比较

#include <time.h>
struct A {
int a[10000];
};
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestFunc3(A* a) {}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 以指针作为参数
size_t begin3 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc3(&a);
size_t end3 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
cout << "TestFunc2(A&)-time:" << end3 - begin3 << endl;
}

2. 值和引用的作为返回值类型的性能比较

#include <time.h>
struct A{ int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a;}
// 引用返回
A& TestFunc2(){ return a;}
void TestReturnByRefOrValue()
{
    // 以值作为函数的返回值类型
    size_t begin1 = clock();
    for (size_t i = 0; i < 100000; ++i)
    TestFunc1();
    size_t end1 = clock();
    // 以引用作为函数的返回值类型
    size_t begin2 = clock();
    for (size_t i = 0; i < 100000; ++i)
    TestFunc2();
    size_t end2 = clock();
    // 计算两个函数运算完成之后的时间
    cout << "TestFunc1 time:" << end1 - begin1 << endl;
    cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

六. 引用和指针

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
    int a = 10;
    int& ra = a;
    cout<<"&a = "<<&a<<endl;
    cout<<"&ra = "<<&ra<<endl;
    return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
    int a = 10;
    int& ra = a;
    ra = 20;
    int* pa = &a;
    *pa = 20;
    return 0;
}

我们来看下引用和指针的汇编代码对比：

引用和指针的不同点:

• 引用在定义时必须初始化，指针没有要求（建议初始化）

• 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

• 没有NULL引用，但有NULL指针

• 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

• 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

• 有多级指针，但是没有多级引用

• 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

• 引用比指针使用起来相对更安全

引用和指针的相同点：

虽然从语法角度来看引用是别名没有额外开空间，但是底层角度来看他们是一样的。

什么是底层角度呢？就是通过编译器处理的结果来看，以下是指针和引用经编译器处理后的结果

我们会发现汇编指令是一致的，这就说明了从底层角度看这两个实现方式是一样的

来源：https://blog.csdn.net/Britney_dark/article/details/124692343