C++引用与指针的区别：深入理解两者特性及选择正确应用场景
C++引用与指针的区别：深入理解两者特性及选择正确应用场景
C++中的引用和指针是两个非常重要的概念，它们在很多场景下可以相互替代，但又各自有其独特之处。本文将深入探讨引用和指针的区别，帮助读者更好地理解它们的特性和应用场景。
一、引用的概念
引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。
所以，铁牛和黑旋风，都是李逵的别名。
引用的概念其实有点相当于指针的平替，以往我们在使用指针时需要取地址 解引用太麻烦了，所以C++在开发时引入了引用的概念。
1.1 引用的语法
类型& 引用变量名(对象名) = 引用实体；
下面是一个引用的实际使用示例：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//给a取别名
int& b = a;
b = 20;
cout << b << endl;
return 0;
}
这时就有很多人说了这引用不就相当于指针吗？对的引用和指针的作用其实是差不多的，对变量引用的修改会影响变量，而指针也是对指针的修改会影响指针所指向的内容：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
void fun(int* x)
{
*x = 20;
}
void fun1(int& y)
{
y = 30;
}
int main()
{
int a = 10;
//使用指针做形参
fun(&a);
cout << a << endl;
//使用引用做形参
fun1(a);
cout << a << endl;
return 0;
}
这里我们就可以看到引用的奇妙之处了。以往我们用指针做参数的时候老是忘记去地址传参，而引用本身就是变量的别名所以，在当形参的时候我们只需要传变量就好了。而在修改变量值的时候指针还要解引用才能修改，而引用却可以直接修改。
现在看来引用和指针对比，简直就是一个还在使用老年机一个却已经使用智能手机全自动了，别急引用的好处还在后面呢大家慢慢看完，我们在以后的项目里面可以说%80的地方都不需要指针而用引用了。
二、引用的特性
2.1 引用必须初始化
以往我们在指针定义时老是忘记初始化而到处野指针的情况频频发生，所以C++规定了引用必须初始化。
int main()
{
int a = 10;
int& b = a;
int& c;
return 0;
}
2.2 引用不能更改指向
指针是可以更改指向的，但是引用不能更改指向。因为C++兼容C语言，可能认为更改指向的事情交给指针做就可以了，没必要让引用去更改指向。
int main()
{
int a = 10;
int x = 30;
int& b = a;
cout << b << endl;
b = x;//不是改变指向而是赋值
cout << b << endl;
cout << a << endl;
return 0;
}
2.3 一个变量可以有多个指向
int main()
{
int a = 10;
int& b = a;
b = 20;
cout << a << endl;
//给别名起别名
int& c = b;
c = 30;
cout << a << endl;
return 0;
}
三、常引用
这里为什么会有常引用的概念呢？引用和指针一样都会去改变所指向的变量从而造成失误。而这时使用常引用就不会了。
void fun(const int& x)
{
x = 30;
}
int main()
{
int a = 10;
fun(a);
return 0;
}
3.1 权限的放大与缩小
- 权限的缩小
int main()
{
int a = 10;
//权限的缩小
const int& b = a;
b = 30;
return 0;
}
这里我们就把变量 a 的别名 b 的权限缩小了，从可读可写变成了可读，所以我们就不能进行修改了。
- 权限的平移
int main()
{
const int a = 8;
//权限的平移
const int& c = a;
const int& b = 10;
return 0;
}
平移很简单就是相同权限的变量我们就给他相同权限的别名才能使用。
- 权限的放大
在我们编程中其实权限是不能放大的，一个常量如果强行把它提升成变量是非常不安全的，所以权限是不能放大的。
3.2 临时变量具有常性
这里给大家看一个代码,这里为什么int 类型可也转换为double double 却转换不了为int 引用？
这是因为当我们进行赋值，或者进行隐式类型转换的时候，这里会产生一个临时变量，而临时变量具有常性。是不可进行，改变和隐式类型转换的。这是我们对其 临时变量的常性，进行权限的平移就会进行报错了。
int main()
{
int a = 10;
double b = a;
const int& x = b;
return 0;
}
那么为什么会产生临时变量？下面看一下这段代码，这里我们进行判断比较时是不会进行提升？
- 那么这里是对变量本身进行提升吗？
int main()
{
int a = 97;
char b = 'a';
if (a == b)
{
cout << "a == b" << endl;
}
}
这里是对临时变量进行对比然后提升进行对比的。
- 权限放大案例
int main()
{
int a = 10;
int b = 20;
//权限的放大，a+b的结果是一个临时变量。临时变量具有常性
//int& b = a + b;
const int& b = a + b;
return 0;
}
四、引用的使用场景
看到这里其实大家，都知道指针和引用的功能大致相同。但是 C++ 的引用是为了替换掉一下指针复杂场景的替换使代码，使代码更加简介但是引用不能代替指针。他们更多的是相辅相成。
做参数
引用的更多使用场景就是传参来用的，以往我们在使用指针更改指针指向的变量，或者二级指针使用起来太不方便了，但是使用引用就非常简单：
void swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 10;
int b = 20;
swap(a, b);
cout << a << endl;
cout << b << endl;
return 0;
}
以往我们在进行交换函数的使用每次都需要，取地址进行传参，而有了引用的概念用起来就方便多了。
做返回值
错误示范：
int& fun()
{
int a = 10;
return a;
}
int& fx()
{
int b = 20;
return b;
}
int main()
{
int& a = fun();
cout << a << endl;
fx();
cout << a << endl;
return 0;
}
这里我们就错误的使用引用做返回值的，我们吧函数 fun 里面本来要销毁的变量给使用别名返回了。但是这个快空间本来是要还给操作系统的：
- 这样我们就造成了内存泄漏
- 当我们在进行调用函数时会对上一个销毁的函数空间进行复用，所以就把原来的空间a给改变了
所以使用引用做返回值的时候一定是对在堆上开辟，或者动态开辟的空间不会随着函数销毁而销毁的空间才可以用引用做返回值。如果不是动态开辟的空间或者再堆上开辟的空间，会随着函数的销毁而销毁就一定要用传值传参。
这里在顺序表里面如果把Get获取函数指定位置的值进行传引用返回的话就可以把修改循序表的Modity给干掉了。一个函数既可以获取值又可以修改值。
struct SeqList
{
int* a;
int size;
int capacity;
//成员函数
void Init(SeqList& sl)
{
int* tmp = (int*)malloc(sizeof(int) * 4);
if (tmp == NULL)
{
perror("malloc file");
exit(-1);
}
sl.a = tmp;
sl.size = 0;
sl.capacity = 4;
}
void PushBack(SeqList& sl,int x)
{
//...
sl.a[size++] = x;
}
int& Get(SeqList& sl, int pos)
{
return sl.a[pos];
}
};
int main()
{
SeqList s;
s.Init(s);
s.PushBack(s, 1);
s.PushBack(s, 2);
s.PushBack(s, 3);
s.PushBack(s, 4);
for (int i = 0; i < s.size; i++)
{
cout << s.Get(s, i) << " ";
}
cout << endl;
for (int i = 0; i < s.size; i++)
{
s.Get(s, i) *= 2;
cout << s.Get(s, i) << " ";
}
cout << endl;
cout << endl;
return 0;
}
4.2 传值和传引用的效率对比
函数在进行传值做形参的话，形参是实参的一份临时拷贝。所以对系统的空间是有一定消耗的，当我们调用函数次数多的话就在效率上就会有一定影响，从而降低效率：
- 下面我们就来测试一下传值调用和传引用调用的效率吧！
#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;
}
int main()
{
TestRefAndValue();
return 0;
}
在这里我们调用一万次他们的差别分别是 8毫秒多 和 0毫秒。
五、引用和指针的区别
5.1 引用与指针的大小
int main()
{
int a = 10;
int& b = a;
int* c = &a;
cout << "引用大小：" << sizeof(a) << endl;
cout << "指针大小：" << sizeof(c) << endl;
cout << "int大小：" << sizeof(int) << endl;
cout << "longlong大小：" << sizeof(long long) << endl;
cout << "引用大小：" << sizeof(long long&) << endl;
cout << "指针大小：" << sizeof(long long*) << endl;
return 0;
}
在sizeof中：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
5.2 引用和指针的底层对比
这边我们定义一个指针和引用，然后我们把它转成汇编代码会发现他们来生成的汇编代码是一样的。所以在底层，引用和指针都是一回事，引用是按照指针方式来实现的。
总结
- 在语法上引用是给一个变量起别名，不开空间。指针是把一个变量的地址存起来。
- 引用必须初始化才能使用，指针可以初始化也可以不初始化
- 引用不可以改变指向，但指针可以改变指向
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
底层上：在底层上引用是开辟空间的，因为引用是用指针实现的。