一、概念
- 引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
- 类型& 引用变量名(对象名) = 引用实体;
- typedef是给类型取别名,&是给变量取别名
- ▲注意:引用类型必须和引用实体是同种类型的
int main()
{
int a = 0;
int& b = a;//引用
cout << &b << endl; // 取地址
cout << &a << endl; // 取地址 两者地址相同
a++;
b++;
return 0;
}
二、引用特征
- 引用在定义时必须初始化,且初始化指定后就不可修改
- 指针不必初始化,但可以改变指向(本文后部分会详细介绍引用和指针区别)
- 一个变量可以有多个引用
- 引用一旦引用一个实体,再不能引用其他实体
int main()
{
int a = 1;
// int& b; // 1、引用在定义时必须初始化
int& b = a; // 2、一个变量可以有多个引用
int& c = a;
int& d = c; // 也可以给别名取别名
++a;
int x = 10;
// 3、引用一旦引用一个实体,再不能引用其他实体
b = x; // b是x的别名呢?还是x赋值给b呢?-->是赋值而非别名(调试看地址和原先别名的a是一样的,这和指针不同)
return 0;
}
三、引用的真正场景
- (1)做参数
- ①输出型参数–>指针也能做,但引用相对舒服点
- ②大对象传参,提高效率–>没有拷贝,引用不开空间
- (2)做返回值
- ①输出型返回对象,调用者可以修改返回对象
- ②减少拷贝,提高效率
- (引用表面是传值,本质也是传地址,不过这个工作有编译器完成)
1、传值返回:生成一个返回对象拷贝作为函数调用返回值
2、传引用返回: 返回返回对象(n)的别名
(1):ret发生越界了,却仍正常输出值,但这属于侥幸
- 返回值取得是n的别名(即tmp),而tmp空间上的值就是n原来的数,但这是侥幸,如果有的编译器销毁后n被置成随机值,tmp就会取到随机值
- 越界:好比申请房间,里面存一个变量,理论上除非别人非法入侵,变量是不会被修改的。但你把房间退了,里面还留着你的东西,就无法保障它不丢失,即使你下回去房间还没租给别人,所以东西被你找到了,也只能说是侥幸(因为换一个房间/编译器,是否还能保证找到就不好说了)。
- 若是调用第二次就未必了(如下图)
- printf也属一个函数调用,也需要建立栈帧,这时栈帧里被printf写入新的值覆盖了原来的count,故第二次再调用printf就是一个随机值了。
- 理解:第一次printf调用后,就被销毁了n,第二次printf再回去找就找失败了。
- printf也属一个函数调用,也需要建立栈帧,这时栈帧里被printf写入新的值覆盖了原来的count,故第二次再调用printf就是一个随机值了。
(2):引用返回的拓展运用:修改顺序数据的函数(指针无法做到)
- 引用做返回值的魅力
void SLInit(SL& s, int capacity)
{
s.a = (int*)malloc(sizeof(int) * capacity);
assert(s.a);
// ...
s.size = 0;
s.capacity = capacity;
}
void SLPushBack(SL& s, int x)
{
if (s.size == s.capacity)
{
// ...
}
s.a[s.size++] = x;
}
//访问某个位置的数据-->充当一个可读可写的作用
int& SLAt(SL& s, int pos)
{
assert(pos >= 0 && pos <= s.size);//检查是否越界
return s.a[pos];//所要改变的数是否存在,在就返回
}
//引用做返回(指针无法替代)
int main()
{
SL sl;
SLInit(sl);//不用指针传参
SLPushBack(sl, 1);
SLPushBack(sl, 2);
SLPushBack(sl, 3);
SLPushBack(sl, 4);
//返回数据
//1 2 3 4
for (int i = 0; i < sl.size; ++i)
{
cout << SLAt(sl, i) << " ";
}
cout << endl;
//修改第0个位置的数据
//2 2 3 4
SLAt(sl, 0)++;
for (int i = 0; i < sl.size; ++i)
{
cout << SLAt(sl, i) << " ";
}
cout << endl;
//10 2 3 4
SLAt(sl, 0) = 10;
for (int i = 0; i < sl.size; ++i)
{
cout << SLAt(sl, i) << " ";
}
cout << endl;
return 0;
}
- SL结构体上的空间是存在堆上的,所以不会被销毁,可以用引用返回
3、总结传值返回和传引用返回:
- 出了函数作用域,返回对象就销毁了,那么一定不能用引用返回,一定要用传值返回
- 下面的这个场景(static),出了作用域变量还在,才能使用引用返回
四、权限放大/缩小/平移
int main()
{
TestReturnByRefOrValue();
return 0;
}
int main()
{
int a = 10;
int& b = a;//a、b都是int,属于权限平移
cout << typeid(a).name() <<endl;//C++中用于读取变量类型的
cout << typeid(b).name() << endl;
// 权限不能放大
const int c = 20;
//int& d = c; //c不能修改,d可以修改,故属于权限放大了-->会报错
const int& d = c;
// 权限可以缩小
int e = 30;//e可读可写
const int& f = e;//f只可读
int ii = 1;
double dd = ii;//会发生隐式类型转化
//double dd = (double)ii;
// 类型转换,并不会改变原变量类型,中间都会产生一个临时变量
//double& rdd = ii;//double不能变成int类型的转变
const double& rdd = ii;
const int& x = 10;
return 0;
}
- 如果使用引用传参,函数内如果不改变n,那么建议尽量用const引用传参
//void func2(int& n)
// 如果使用引用传参,函数内如果不改变n,那么建议尽量用const引用传参
void func2(const int& n)
{
……
}
五、引用和指针的区别
-
对于引用
- ①语法概念:引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
- ②底层实现:实际是有空间的,因为引用是按照指针方式来实现的。
-
引用和指针的不同点:
- (理解记忆①使用场景②语法特性及底层原理)
- ①使用场景:
- 指针和引用用途基本是相似的(能用指针的地方基本能用引用,能用引用的地方也基本能用指针),它们一般都是用于做一些参数、返回值的地方,它们有提高效率、做输出型参数返回对象这样的,但一般这些场景引用更合适的。
- 指针有引用替代不了的地方:如C++中这种链表、链式结构的场景,引用无法替代。
- a.引用必须在定义的时候初始化(指针可以初始化,也可以不初始化)
- b.引用指向一个实体后,就不能再引用其他实体
- 指针更强大,更危险,更复杂;引用相对局限一些,更安全,更简单
- ②语法特性及底层原理
- 语法角度而言,引用没有开空间,指针开了4 or 8 byte(根据计算机32位 or 64位)
- 底层实现角度,引用底层是用指针实现的
- ①使用场景:
- (理解记忆①使用场景②语法特性及底层原理)
//①引用必须在定义的时候初始化(指针可以初始化,也可以不初始化)
//②引用指向一个实体后,就不能再引用其他实体
struct ListNode
{
int val;
struct ListNode*next;
//此句不能修改做struct ListNode&next;
}
- 引用概念上定义一个变量的别名,指针存储一个变量地址
- 引用在定义时必须初始化,指针没有要求(指针不初始化其值为随机指向)
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用,但有NULL指针
- 空指针没有任何指向,删除无害,引用是别名,删除引用就删除真实对象
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全
- 指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。程序中使用指针,程序的可读性差;而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作