引用的实质及其与指针的关系（通过指针可修改其引用所指向的值）

1.引用作为变量别名而存在，因此在一些场合可以代替指针
2.引用相对于指针来说具有更好的可读性和使用性
（2）交换函数实现对比

 ①传入指针：

#include <iostream>
#include <stdio.h>
 
void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}
 
int main()
{
    int a = 1;
    int b = 2;
    swap(&a, &b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}
编译运行：

②传引用：

#include <iostream>
#include <stdio.h>
 
void swap(int& a, int& b)
{
    int t = a;
    a = b;
    b = t;
}
 
int main()
{
    int a = 1;
    int b = 2;
    swap(a,b);
    printf("a = %d, b = %d\n", a, b);
    system("pause");
    return 0;
}
 

 发现输出的结果是一样的。

但是，传入引用这种方法更好一些，相当于直接传入值;而传指针这种方法，还需要将传入的值转换成地址，然后再传给指针。

（3）特殊的引用-const引用

特点：

1.在C ++中可以声明const的引用
2.const type＆name = var;
3.const引用让变量拥有只读属性
实例代码：

#include <iostream>
#include <stdio.h>
 
int main()
{
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;
    b = 5; //Error,b是只读变量
    *p = 5; //OK,修改变量a的值
    system("pause");
    return 0;
}
编译运行：

 

可见，B是只读变量，但是可以通过* P指针修改一个的值。

 注意：当使用常量对常量引用进行初始化时，C ++编译器会为常量值分配空间，并将引用名作为这段空间的别名。

（4）实例分析：引用的特殊意义

实例代码：

#include <stdio.h>
#include <iostream>
 
void Example()
{
    printf("Example:\n");
 
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;
 
    //b = 5;
 
    *p = 5;
 
    printf("a = %d\n", a);
    printf("b = %d\n", b);
}
 
void Demo()
{
    printf("Demo:\n");
 
    const int& c = 1;
    int* p = (int*)&c;
 
    //c = 5;
 
    *p = 5;
 
    printf("c = %d\n", c);
}
 
int main(int argc, char *argv[])
{
    Example();
 
    printf("\n");
 
    Demo();
 
    system("pause");
    return 0;
}
编译运行：

可见，引用只是 一个别名，可以通过指针修改它的值。

 

（5）引用有自己的存储空间吗?

我们看一段示例代码：

#include <stdio.h>
 
struct TRef
{
    char& r;
};
 
int main(int argc, char *argv[])
{ 
    char c = 'c';
    char& rc = c;
    TRef ref = { c };
    
    printf("sizeof(char&) = %d\n", sizeof(char&));
    printf("sizeof(rc) = %d\n", sizeof(rc));
    
    printf("sizeof(TRef) = %d\n", sizeof(TRef));
    printf("sizeof(ref.r) = %d\n", sizeof(ref.r));
 
    return 0;
}
编译运行：

可见结构体TRef占用4个字节。

（6）引用在C++中的内部实现是一个指针常量（它的本质是指针）

注意：

1.C++编译器在编译过程中用指针常量作为引用的内部实现，因此引用所占用的空间大小与指针相同
2.从使用的角度，引用只是一个别名，C++为了实用性而隐藏了引用的储存空间这一细节
 编程实验：引用的存储空间

#include <stdio.h>
#include <iostream>
struct TRef
{
    char* before;
    char& ref;
    char* after;
};
 
int main(int argc, char* argv[])
{
    char a = 'a';
    char& b = a;
    char c = 'c';
 
    TRef r = { &a, b, &c };
 
    printf("sizeof(r) = %d\n", sizeof(r));
    printf("sizeof(r.before) = %d\n", sizeof(r.before));
    printf("sizeof(r.after) = %d\n", sizeof(r.after));
    printf("&r.before = %p\n", &r.before);
    printf("&r.after = %p\n", &r.after);
 
    system("pause");
    return 0;
}
 
 编译运行：

 

可见，    char& ref 占用了4个字节，说明了引用的本质就是指针，指针占用4个字节

 

（7）引用的意义

C++中的引用旨在大多数的情况下代替指针：

1.功能性：可以满足多数需要使用指针的场合
2.安全性：可以避开由于指针操作不当而带来的内存错误
3.操作性：简单易用，又不失功能性
 （8）实例分析：函数返回引用

#include <stdio.h>
#include <iostream>
int& demo()
{
    int d = 0;
 
    printf("demo: d = %d\n", d);
 
    return d;
}
 
int& func()
{
    static int s = 0;
 
    printf("func: s = %d\n", s);
 
    return s;
}
 
int main(int argc, char* argv[])
{
    int& rd = demo();
    int& rs = func();
 
    printf("\n");
    printf("main: rd = %d\n", rd);
    printf("main: rs = %d\n", rs);
    printf("\n");
 
    rd = 10;
    rs = 11;
 
    demo();
    func();
 
    printf("\n");
    printf("main: rd = %d\n", rd);
    printf("main: rs = %d\n", rs);
    printf("\n");
 
    system("pause");
    return 0;
}
 
编译运行：

然而，此时会出现一个警告：

 说明，不能返回一个局部变量的引用，并且在输出的是一个随机值，说明此时是一个野指针。而static int s = 0;可以返回s，是因为static的局部变量在全局上分配空间。

（9）总结

1.引用作为变量别名而存在旨在代替指针
2.const引用可以使得变量具有只读属性
3.引用在编译器内部使用指针常量实现
4.引用的最终本质为指针
5.引用可以尽可能的避开内存错误
<全文完>

 
————————————————
版权声明：本文为CSDN博主「Civil跨界工程师」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_40416052/article/details/82226846