C++入门学习（4）引用 （讲解拿指针比较）

上期回顾

在学习完函数重载之后，我们可以使用多个重名函数进行操作，会发现C++真的是弥补了好多C语言的不足之处，真的不禁感概一下，时代的进步是需要人去做出改变的，而不是一味的使用啊！所以我们今天继续学一下C++对C语言的指针的改变吧！

一、引用的诞生

在C语言中，指针的使用是很复杂的，涉及了二级指针，三级指针乃至我们很少见的多级指针，这会让我们使用起来很麻烦，程序的可读性很差，如果你不是一个功底很深的程序员，根本就要花上很长时间才会略知一二。

但是我们在C++中并不是摒弃了指针，而是发明了一个新的东西，在某些场合可以代替指针----引用！

二、引用的概念

那什么是引用呢？

我们语文中的引用是不是给某个东西起个别名，然后再用双引号引起来。在现实生活中，我们会有很多别名，比如李逵，在家叫"铁牛"，江湖人称"黑旋风"。这都是引用，所以我们C++中的引用也不例外，就是给一个变量起别名。
我们来一起思考一个问题，C++中的引用，会开辟一个新的内存空间吗？因为在C语言中指针会开辟空间的。

我们还是以现实生活为例，你有很多别名，那就有很多个你吗？肯定不是吧！

所以我们C++的引用，也是只有一个空间的，我们只是给变量起了个别名，但是引用是跟它引用的变量共用一块内存空间的。

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

我们了解了概念之后，那引用是如何使用的呢？

三、引用的使用

数据类型**&**引用变量名 = 引用实体
**注意：****引用的数据类型要和引用实体数据类型一致（**不一致的情况我们放在常引用讲解 ）

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    int&a1 = a;
   
    cout << "a = "<< a << endl << "a1 = "<< a1 << endl;
    return 0;
}

看到下面的输出结果，也印证了引用是给变量取别名

四、引用的特性

4.1 引用必须初始化

如果我们写了这样的一段代码：是编译不过去的，会报错，正是因为引用没有初始化出现的错误。我们可以这样理解，引用实体都没有，哪里来的引用呢？就像一个人根本不存在，他就不可能有别名的。

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    int&a1;

    return 0;
}

4.2 引用的改变 会 改变引用实体

那如果是这样的代码呢？我们在此基础上➕了一行a1++，改变引用会改变引用实体吗？

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    int&a1 = a;
    
    a1++;
    cout << "a = "<< a << endl << "a1 = "<< a1 << endl;
    return 0;
}

答案是一定的，因为引用跟引用实体共用同一个空间，改变引用就是改变引用实体。

4.3 引用不改变指向，也不可以同时引用多个实体

那一个引用可以引用多个实体吗？或者可以改变引用指向的对象吗？因为我们C语言的指针可以改变指向，所以我们来探讨一下，比如下面这段代码：

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    int&a1 = a;

    int b = 5;
    a1 = b;
    
    cout << "a = "<< a << endl << "a1 = "<< a1 << endl;
    cout << "a的地址为："<< &a << endl;
    cout << "a1的地址为："<< &a1 << endl;
    cout << "b的地址为："<< &b << endl;
    return 0;
}

我们可以看到，虽然把b的值赋给了a1，但是没有改变引用的指向，a1的地址还是跟a一样的，引用跟指针的区别之一也显现出来了，所以我们可以得出下面两个结论：
1. 引用不可以引用多个对象；

2. 引用不可以改变指向（指向的对象）；

4.4 一个实体可以有多个引用

在日常生活中，你可以有很多个别名，所以在C++中，一个实体也可以有多个引用。

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    int& a1 = a;
    int& a2 = a;
    int& a3 = a;

    cout << "a = "<< a << endl;
    cout << "a1 = "<< a1 << endl;
    cout << "a2 = "<< a2 << endl;
    cout << "a3 = "<< a3 << endl;
    return 0;
}

因为一个实体可以有多个引用，所以这个输出就一定都会是3的。

我相信大家一定会有这样的疑问，我们上面所做的事情，C语言的指针也可以做呀，没什么特别的嘛，大家不要着急，继续看下去，引用使用的地方并不是在这里哦！

我们可以发现，目前的引用都是在引用变量，那是否可以引用常量或者是常变量呢？接下来是我们要讲的重点之一：

五、常引用

在学习之前，我们要先知道这个概念

权限：一般是指我们可以操作的范围，使用的范围，权限只可以平移和缩小，不可以放大
了解之后，我们就开始对常引用的学习吧！

那什么是常引用呢？就是对常量和常变量的引用，但是一定要记住权限，来看下面的代码:

#include <iostream>
using namespace std;
int main()
{
    const int a = 3;
    int& a1 = a;
    
    return 0;
}

这段代码可以正常运行吗？

我们先来分析一下，在程序中我们定义了一个常变量a，a本来是变量，但是被const修饰了，变得不可被修改，所以权限是 "只读"，然而我们用int类型的引用来去引用a是不可以的，因为我们的引用变量a1是int类型的，权限是"读和写"，可以被修改。所以这里的权限是被放大了，a1可以修改，a不可以修改，权限被放大，该程序错误

那怎么弄才是对的呢？还是得看权限只能平移和缩小，所以我们更改了代码：

#include <iostream>
using namespace std;
int main()
{
    const int a = 3;
    const int& a1 = a;
    
    return 0;
}

这段代码中，a是常变量，引用变量a1也是常变量，这是权限的平移，程序正确。

那有没有权限缩小的呢？当然有，来看下面代码：

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    const int& a1 = a;
    
    return 0;
}

这段代码就是a本来可以修改，是"读写"，然后我们的引用变量a1是➕const修饰的，权限是"只读"，这里就是权限的缩小，程序正确。

以上都是对常变量的引用，那如何来引用常量呢？

猜对了，还是靠权限来：

#include <iostream>
using namespace std;
int main() 
{
    const int &a1 = 3;

    return 0;
}

我们的常量，也是不可被修改的，权限是"只读"，所以要引用常量的时候，要加上const，把权限也变成"只读"

六、引用和引用实体的数据类型不同

当我们了解了这些之后，我们要填一下上面埋的坑，当引用和引用实体的数据类型不一样的时候，如何引用呢？

我们要了解一个概念**，当类型不同的时候，一定会发生类型转换**，比如下面的代码：

#include <stdio.h>
int main()
{
    int a = 3;
    double b = a;
    printf("a = %d\nb = %lf",a,b);
    return 0;
}

我们先定义了一个整形变量a，再将a变量赋值给double类型的b，两个类型不同，会发生隐式类型转换，就是把a转换成double类型，再赋值给b，那我们的a的数据类型是什么呢？

从上面可以看出a还是整型，但是不是把a转换成double之后，再赋值给b的吗？怎么a还是int类型？我们带着这样的疑问，去学习一个新的知识：

凡是涉及到类型的转换，都会产生一个****临时变量 **，存放转换的值。**这个临时变量具有常属性

这也就解释了为什么a还是int类型。

我们用图解的方法来看一下：

我们在了解上面的概念之后，看下面的代码：

#include <iostream>
using namespace std;
int main()
{
    int a = 3;
    const double& b = a;
    
    return 0;
}

我们定义了一个int类型的变量a，用double类型的引用变量去引用a，因为类型不同，会发生类型转换，但本质是先创建一个double类型的中间变量，再把a的值转换到这个中间变量中，由这个中间变量赋值给我们的b，为什么要➕const，因为这个中间变量具有常属性。

七、引用的使用场景

其实在上面我们仅仅是在介绍引用该怎么使用，没有介绍引用都用在哪里，所以接下来我们来学习引用使用场景。

7.1 做函数参数

我们在C语言中写一个交换函数，是需要传地址的，也就是用到一级指针：

void Swap(int* x,int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

而在C++中，我们可以用引用来解决这个问题：

因为引用就是引用实体的别名，所以改变引用就是改变引用实体。

void Swap(int& x,int& y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

7.2 做返回值

第二个用途就是用引用当返回值

但是有一个条件：函数返用引用作为返回值的时候，返回值不可以被销毁

下面的例子主要是讲解，我们用引用做返回值的时候，返回值不可以被销毁。

我们先看这样的一段代码：

我们是定义了一个函数Count，里面实现的是简单的n++，n最后是1，然后将n的值返回，可是n是函数里面创建的一个临时变量啊，临时变量出了作用域就销毁了

而我们函数的返回值是n的引用，引用实体销毁了，引用还能正常使用吗？肯定不能的对吧，但是这里要分两种情况，ret可能是1，也可能是随机值，这主要看编辑器销毁的速度。

int& Count()
{
    int n = 0;
    n++;
    // ...
    return n;
}
using namespace std;
int main()
{
    int& ret = Count();
    cout << ret << endl;
    return 0;
}

如果我们是下面的代码呢？打印出来的结果又是什么呢？

很神奇吧，一个是3可以理解，有可能是z没有被销毁，但是后面怎么是10了呢？

这是因为我们函数栈帧是可以复用的，所以我们的那个空间本来是3，后来虽然被销毁了，又被征用了，变成10了。而我们的引用还是指向那个位置的，所以就变成10了，但是也可能是随机值。

int& Add(int x,int y)
{
    int z = x + y;
    return z;
}
using namespace std;
int main()
{
    int& ret = Add(1,2);
    cout << ret << endl;
    Add(3,7);
    cout << ret << endl;
    return 0;
}

但是有没有什么办法来解决这样的问题呢？也就是保证返回值不被销毁。

我们可以定义一个静态变量就可以了，因为静态变量是在堆上开辟的，函数的销毁不会影响静态变量。

需要注意的一点就是：局部的静态变量只可以初始化一次

多次进入这个函数，只会执行一次初始化，剩下的都跳过
这样我们就可以正确的返回z的引用了，

int& Add(int x,int y)
{
    static int z = x + y;
    return z;
}
using namespace std;
int main()
{
    int& ret = Add(1,2);
    cout << ret << endl;
    return 0;
}

所以我们的我们函数返回值要是引用的话，返回值不呢被销毁

八、传值和传引用的效率比较

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

8.1 函数参数 用 引用和值 的效率比较

#include <time.h>
#include <iostream>
using namespace std;
struct A
{
    int a[10000];
};
void TestFunc1(A a)
{

}
void TestFunc2(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();

// 分别计算两个函数运行结束后的时间

    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
    TestRefAndValue();
    return 0;
}

我们可以看到当数据过大的时候，函数参数用引用的效率很快！

8.1 函数返回值用引用和值的效率比较

#include <iostream>
#include <time.h>
using namespace std;
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()
{
    TestReturnByRefOrValue();
    return 0;
}

当数据过大的时候，函数返回值用引用的效率更快

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。这就是引用的优势，不需要开辟临时空间。

九、引用和指针的区别

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

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

4. 没有NULL引用，但有NULL指针

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

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

7. 有多级指针，但是没有多级引用

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

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

10. 空指针没有任何指向，删除无害，引用是别名，删除引用就删除真实对象