前言

在C语言的学习中，并没有引用这个概念，但是在C++中，加入了引用这个概念，说明引用也是很重要的，但是我们怎么理解引用呢？我是这么理解的，例如在水浒传中，108个英雄好汉都是自己的外号，例如及时雨宋江，豹子头林冲，花和尚鲁智深等等，我们就可以将引用理解为一个变量的外号，既然是外号，说明虽然名称不同，但是还是指的是同样的人。

引用概念

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

    int a = 10;
    int& b = a;
    cout << a << "   " << b << endl;
    cout << &a << "   " << &b << endl;
    return 0;

通过执行我们发现，不仅a和b的值相同，而且他们的地址也是相同的，这也就证明了引用和本体使用同一块内存空间。

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

引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

1.定义时必须初始化，在定义c时，并没有初始化，这时非法的，因为引用就是一个外号，没有一个本体，那么是给谁取外号呢？这显然是不行的。

2.一个变量可以有多个引用，还是以刚才水浒传的例子，李逵在家时被叫做“铁牛”，但是有的人还把他叫做“黑子”，还有人叫他“黑旋风”，我们的引用也是类似，一个本体可以有多个引用。

    int a = 10;
    int& b = a;
    int& c = b;
    int& d = a;
    printf("%d %d %d %d\n", a, b, c, d);
    printf("%p %p %p %p\n", &a, &b, &c, &d);
    return 0;

我们发现，虽然他有四个名字，但是本质上还是一个变量，拥有同样的内存空间。

3. 引用一旦引用一个实体，再不能引用其他实体，意思就是“引用”是一个忠诚的男人，自打初始化开始，引用只要成立，就会一直跟着本体。

    int a = 10;
    int c = 20;
    int& b = a;
    b = c;
    printf("%d %d %d \n", a, b, c);
    printf("%p %p %p \n", &a, &b, &c);

我们发现当我们对b进行赋值时，并不会改变a和b的引用关系，只会改变他的值，所以说“引用”是一个忠诚的男人。

常引用

有时候，我们需要引用的是一个常量，我们就必须使用常量引用。

    const int a = 10;
    // 该语句编译时会出错，a为常量,这样会将权限扩大   
    //int& ra = a;  
        
    const int& ra = a;
    // 该语句编译时会出错，b为常量
    // int& b = 10; 

    const int& b = 10;
    double d = 12.34;
    // 该语句编译时会出错，类型不同
    //int& rd = d; 
    const int& rd = d;

使用场景

引用一般有两个使用场景，第一个场景是做函数的参数，第二个是做函数的返回值。

做参数

当我们要交换两个变量的值，我们要传入指针才能改变实参的值。

// 1、引用做参数
void swap(int* p1, int* p2) // 传地址
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

void swap(int& r1, int& r2) // 传引用
{
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

我们前边在实现单链表的时候，我们需要传入二级指针，是为了修改一级指针的，为了让形参的改变影响到实参。

当然在学习了C++的引用之后，我们就可以使用引用传递参数来代替二级指针传递参数。

部分代码示例：

int* singleNumbers(int* nums, int numsSize, int& returnSize){
//int* singleNumbers(int* nums, int numsSize, int* returnSize){
    int* a = (int*)malloc(sizeof(int) * 2);

    //...

    //*returnSize = 2;
    returnSize = 2;
    return a;
}

int TestList()
{
    SLTNode* plist = NULL;
    SListPushBack(plist, 1);
    SListPushBack(plist, 2);
    SListPushBack(plist, 3);
    SListPushBack(plist, 4);
    SListPushFront(plist, 5);
    SListPushFront(plist, 6);
    SListPushFront(plist, 7);

    SListPrint(plist);

    return 0;
}

2.做返回值

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;
}

为什么会出现这样的结果呢？那是因为我们对函数进行了引用传返回值，此时的ret就是c的引用，也就是c的别名，此时再调用Add(3,4)时，ret也被改为了他的值，ret会随着函数返回结果的改变而改变。

传值、传引用效率比较

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

#include <time.h>
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;
}

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

#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;
}

我们通过反汇编来观察，发现引用底层还是通过指针实现的，底层也是要开不同的空间的。

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

总结

这篇文章介绍了“引用”的相关操作，并且讲解了“引用”和“指针”的不同，希望大家点赞收藏。

【C++】一篇带你搞懂C++“引用”

前言