一篇文章带你搞懂C++引用（建议收藏）

引用

6.1 引用概念

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

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"

typedef 是给类型取别名

引用是给变量取别名

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

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

int main()
{
    int a = 0;//定义一个变量a,赋值为0,
    int &b = a;//这里的&不是取地址符,而是引用,给变量取别名, &定义在一个类型和变量之间为引用
    //定义一个空间为a,又给这个空间a取别名为b
    
    int a = 0;
    int b = a;//这种写法和上面是完全不同的,
    //这里是 定义一个变量为a,a的值是0,定义一个变量为b,用a的0初始化
    return 0;
}

如何证明是否公用一块空间?

#include <iostream>
using namespace std;

int main()
{
    int a = 0;
    int& b = a;

    cout << &b << endl;//取地址
    cout << &a << endl;//取地址
    
    a++;
    b++;

    return 0;
}

6.2 引用的特性

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

int main()
{
    int a = 1;
    int& b;//引用在定义时必须初始化
    return 0;
}

2. 一个变量可以有多个引用(可以取无限个别名)

int main()
{
    int a = 1;
    int &b = a;
    int &c = a;
    int &d = c;//还可以给别名取别名
    
    a++;
    
    return 0;
}

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

指针指向一个实体后,可以改变,引用不可以改变

int main()
{
    int a = 1;
    int& b = a;
    int& c = a;
    int& d = c;
    int x = 10;
    //引用一旦拥有一个实体,再不能引用其他实体
    b = x;b是x的别名呢?还是x赋值为b?

    return 0;
}

这里把x赋值给b

6.3 常引用

权限不能放大

int main()
{
    int a = 13;
    int& b = a;
    
    //权限不能放大
    const int c = 20;
    //int& d = c;
    const int& d = c;
    
    //权限可以缩小,从只读的角度
    int e = 25;
    const int& f = e;      
    return 0;
}

隐式类型转换和强制类型转换都是会产生临时变量

所有的转换都不是对原变量进行转换和提升,而是之间产生临时变量

并不会改变原变量类型,

这里本质上是权限的放大和缩小

类型转换中间是会产生临时变量的,临时变量具有常性,相当于const修饰

int main()
{
    int ii = 1;
    doubble dd = ii;//int类型可以给double,会发生隐式类型转换
    double& rdd = ii;//double类型的数据可以变成int的引用吗?
    //不可以  这里不能引用的原因不是说类型不匹配,而是不能进行权限的放大
    const double& rdd = ii;
    //这里可以引用是因为权限的平移 中间产生的临时变量也是相当于const修饰的变量
    //此时rdd引用的不是ii,而是int转换成double之间产生的临时变量,
    //这个临时变量具有常性

    return 0;
}

const 可以把一个常量起一个别名

const int& x = 10;

应用场景:

如果使用引用传参,函数内如果不改变n,那么尽量用const引用传参

const引用传参会有非常强的接受度

        

6.4 引用的使用场景

1.做参数

a.输出型参数

b.大对象传参,提高效率

2.做返回值

a.输出型返回对象,调用者可以修改返回对象.

b.减少拷贝提高效率,

不是什么时候都可以使用传引用返回,要注意使用场景

出了作用域,返回对象还在可以用传引用返回

出了作用域,返回对象销毁.那么一定不能用引用返回,一定要用传值返回

1. 做参数 --(引用的输出型参数)

如果不用引用,传入的是实参的一份临时拷贝,形参的改变不会影响实参

如果想改变 必须使用指针 传入地址

在C++里,这里x是a的别名,y是b的别名,x和y的交换就是a和b的交换

void Swap(int& x, int& y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int a = 3;
    int b = 5;
    cout <<"交换前:" << a << ' ' << b << endl;
    Swap(a, b);
    cout <<"交换后:" << a << ' ' << b << endl;
    return 0;
}

例如:有些书里会把数据结构里链表部分弄得很复杂

typedef struct SListNode
{
    .....
}SLTNode,*PSLTNode;
//这里的*PSLTNode 相当于typedef struct SListNode* PSLTNode  给这个结构体指针起了个别名 PSLTNode
void SListPushBack(PSLTNode& phead,int x)//这里的引用相当于 phead是list的别名,phead的改变会影响list
{
    .....
}
int main()
{
    SLTNode* list = NULL;
    SListPushBack(list,1);
    SListPushBack(list,1);
    SListPushBack(list,1);
    return 0;
}

大对象传参 提高效率

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

2. 做返回值

传值返回 都会生成一个返回对象拷贝作为函数调用的返回值

返回的是n吗 是用n的拷贝来做表达式的返回值

为什么编译器要这么做?

如果这里没有static ,n返回时,出了该作用域 会销毁 置为随机值

传引用返回:

引用返回的语法含义:返回返回对象的别名

不是什么时候都可以使用传引用返回,要注意使用场景

返回n的别名 越界了为什么不报错呢?

ret的结果是未定义的 如果栈帧结束时,系统清理栈帧置成随机值,那么这里ret的结果就是随机值

下面程序使用引用返回本质是不对的,结果是没有保障的

int& Count()
{
    int n = 0;
        n++;
    // ...
    return n;
}
int main()
{
    int ret = Count();

    return 0;
}

如果引用ret ,那么相当于 ret也是n的别名,结果会不会有所不同

int& Count()
{
    int n = 0;
        n++;
    // ...
    return n;
}
int main()
{
    int& ret = Count();
    printf("%d\n", ret);
    printf("%d\n", ret);
    printf("%d\n", ret);
    printf("%d\n", ret);
    return 0;
}

总结:出了函数作用域,返回对象就销毁了,那么一定不能用引用返回,一定要用传值返回

什么时候可以用引用返回?

使用static

1. static修饰变量

   a. 函数中局部变量：

      声明周期延长：该变量不随函数结束而结束

      初始化：只在第一次调用该函数时进行初始化

      记忆性：后序调用时，该变量使用前一次函数调用完成之后保存的值

      存储位置：不会存储在栈上，放在数据段

int& Count()
{
    static int n = 0;
        n++;
    // ...
    return n;
}
int main()
{
    int& ret = Count();
    printf("%d\n", ret);
    printf("%d\n", ret);
    printf("%d\n", ret);
    printf("%d\n", ret);
    return 0;
}

const引用

为什么这里给c取别名不可以?

本质上是权相的放大 c自己是const类型 不可以修改

用d取别名 使得d是权限的放大 可以修改

#include <iostream>

using namespace std;

int main()
{

    int a = 10;//权限的的平移
    int& b = a;

    const int c = 20;//权限的放大
    int& d = c;
 
          int e = 30;//权限的缩小
          const int&f = e;//只读的角度变成你的别名

    return 0;
}

权限不可以放大,但是权限可以缩小

int main()
{
    int ii = 1;
    double dd = ii;//发生隐式类型转换
    double& rdd = ii;//double不可以变成int的引用
    //不可以使用的本质原因是 因为权限的放大,因为 int 类型要转换成double类型
    //中间要先生成一个double类型的临时变量,相当于 const double ii;
    //double& dd = const double ii; //权限的放大不可以
    const double& rdd = ii;
    //可以使用权限的平移
    return 0;
}

强制转换并不是改变原变量类型 他也是产生一个临时变量

如果使用引用传参,函数内如果不改变n,那么尽量用const引用传参

void func1(int& n)
{
    
}
void func2(const int& n)
{
    
}
int main()
{
    int a = 10;
    const int b =20;
    func1(a);
    func1(b);
    func1(30);
    
    func2(a);
    func2(b);
    func2(30);
    double c = 1.11;
    
    func2(c);
    return 0;
}

指针和引用的差别

指针和引用用途基本是相似的

但有

1.使用场景的差别

引用和指针的不同点:

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

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

实体

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

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

4个字节)

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

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

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

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

2.语法特性以及底层原理的差别

从语法角度而言,引用没有开辟空间,指针开了四个字节或者8个字节的空间

底层实现角度,那么引用底层是用指针实现的

个人水平不足 如果代码中有错误，可以多多在评论区指出，一定会及时修改！
谢谢大家看到这里 觉得有收获的话可以三连一下 一起加油！