C++引用的概念(非常细节)
今天,我们来了解一下C++中的引用的概念,引用算是C++当中比较常用的一个知识点！
引用
C语言中函数的传参有两种方式：
1.传值 2.传址
虽然这两种方式都可以实现函数传参但是却各自有着自己的优缺点：
传值：无法改变形参的值 , 传址：不是很形象而且不安全, 在升级版C++中为了解决这种问题就使用了引用&
概念
引用不是新定义一个变量,而是给已存在变量取了一个别名, 编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间,
引用的方法：
- 类型& 引用变量名(对象名) = 引用实体；
例子1
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//引用定义
int& b = a;
//取地址
int* pa = &a;
//编译器不会为引用变量开辟内存空间
cout << "&a = " << &a << endl;
cout << "&b = " << &b << endl;//引用变量和他引用的变量地址相同
cout << "pa = " << pa << endl;//pa是指针,保存的是a的地址
} 
引用在语法层面看,我们要理解成没有开辟新空间,就是对原来的变量取了一个别名
例子
void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
} 注意：引用类型必须和引用实体是同种类型的
//err
int main()
{
int a = 10;
double& b = a;
} 
引用特性
- 1.引用在定义时必须初始化
int a = 10; int& b;//err必须初始化
- 2.一个变量可以有多个引用-类似一个人可以有多个代号
int a = 10; int& b = a; int& c = b; int& d = a;
- 3.引用一旦引用一个实体,再不能引用其他实体
int main()
{
int a = 10;
int& b = a;
cout << "b = " << b << endl;
cout << "&a = " << &a << endl;
int c = 20;
b = c;
//这里是把b变成c的别名还是把c的值赋给b？
cout << "b = " <<b<< endl;
cout << "&b = " << &b << endl;
return 0;
} 所以是把c的值赋给b ,引用一旦引用一个实体,再不能引用其他实体
- 4.引用变量的名不能和其它变量名同名
int main()
{
int a = 10;
int& b = a;
double b = 1.1;//err
} 
==总结：==
- 引用必须初始化
- 一个变量可以有多个引用（就好比一个人可以有多个绰号）
- 引用一旦引用实体,再不能引用其他实体
- 不能建立引用数组
- 不能建立引用的引用
- 没有引用的指针
- 可以取引用的地址（其实也就是取变量的地址）
- 区别引用声明符&和地址运算符&,（出现在声明中的&是引用声明符其他的是地址运算符）
常引用
若加了const修饰的变量：称为常变量,仍是变量,但是只可读,不可写(不可修改变量的值),
case 1: 权限放大 err
//b和a占用同一块空间 const int a = 10; //a ：只读 int& b = a; //b：可读可写
case2：权限不变：可以
const int a = 10; const int& b = a;//a和b都是只读 int a = 10; int& b = a;//a和b都是可读可写
case3:权限缩小 - 可以
int a = 10;//a：可读可写 const int& b = a; //b：只可读
对于类型不同的变量进行引用要加const：
因为类型不同的变量赋值会产生临时变量,这个临时变量是不能修改的,所以要用const修饰
int main()
{
double d = 3.14;
//int& rd = d; //err类型不同
const int& b = d;//OK
return 0;
} 总结：
int a = 10; int& b = a;//OK //double& d = a;//err const double& d = a;//OK
b就是a的别名,类型相同的引用不会创建临时变量
double&类型的引用 只能引用double类型的变量 要引用类型必须要一致, int和double之间可以隐式转换 编译器在这个过程中生成了一个临时变量 d引用的不是a ,而是引用的是生成的临时变量,因为临时变量具有常性 所以前面要加const
结论：
==1.类型不同的变量进行引用要加const==
==2.const Type &可以接受任何类型的对象==
int a = 10; char c = 'a'; double d = 3.14; //const int& i1 = a;//OK //const int& i1 = c;//OK //const int& i1 = d;//OK
验证不同类型,引用的不是本身,而是临时变量
例子
假设x是一个大对象或者是深拷贝的对象,那么尽量使用引用传参,减少拷贝, 而且如果函数中不改变传的参数,尽量使用const引用传参
//引用传参
void func(int& x)
{
cout<< x <<endl;
}
int main()
{
const int a = 10;
const int&b = a;
func(a);//err a可读 引用传参给x,x是可读可写,权限放大,err
func(10);//err 10是常数只可读
} 
//引用传参,加上const修饰后
//x变成只可读了,权限不变,所以可以
void func(const int& x)
{
cout << x << endl;
}
int main()
{
const int a = 10;
const int& b = a;
func(a); //10
func(10); //10
} #define M 10
int main()
{
const int& b = M;//ok,b：只可读 M：只可读 权限不变
// int& c = M;//err M是常数只可读,而c可读可写,权限扩大
} 引用的使用场景
1.引用做函数参数
case1：
//函数修饰名：_Z4swappipi
void Swap(int* p1,int* p2)//传地址
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//函数修饰名：_Z4swapii
void Swap(int r1,int r2)//传值
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
//函数修饰名：_Z4swapriri
void Swap(int& r1,int& r2) //传引用
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
问1：上述三个交换函数构成函数重载吗
函数修饰名不同,构成函数重载,但是Swap(x,y)调用时会存在歧义,它不知道调用的是传值还是传引用
传引用相当于把空间传过去,改变形参的内容,实参的内容也会发生改变
//r1,r2就是a,b的别名,r1,r2的改变就是改变a,b
void Swap(int& r1, int& r2) //传引用
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
int main()
{
int a = 1;
int b = 2;
cout << "a = "<< a<<" b = "<<b << endl;
Swap(a, b);
cout << "a = " << a << " b = " << b << endl;
return 0;
} 
case2：二级指针 = = 传指针的引用
首先要知道：
函数内要改变整形变量的值：传一级指针, 要改变一级指针的内容：传二级指针, 但是使用指针的引用就不用这么麻烦,改变一级指针,只需要传一级指针的引用即可
//传一级指针
void func1(int* pa)
{
pa = (int*)malloc(sizeof(int)*4);
}
//传二级指针
void func2(int** ppa)
{
*ppa = (int*)malloc(sizeof(int) * 4);
}
//传引用
void func3(int*& pa)
{
pa = (int*)malloc(sizeof(int) * 4);
}
int main()
{
int* p = NULL;
cout << "p = " << p << endl; //NULL
func1(p);//传一级指针
cout << "p = " << p << endl;
func2(&p);//传二级指针
cout << "p = " << p << endl;
func3(p);//传引用
cout << "p = " << p << endl;
return 0;
} 函数内部为p开辟一块空间
传二级指针和传一级指针引用都可以改变一级指针的内容
2.引用做返回值
首先,我们要知道：所有的传值返回都会生成临时变量(临时拷贝)
临时变量 (临时拷贝存在哪里)
- 如果返回的变量比较小(4/8个字节),一般是寄存器
eax充当临时变量 - 如果返回的变量比较大(如：结构体),临时变量存放在调用该函数的栈帧中
例子
//传值返回
int Add(int x, int y)
{
int c = x + y;
return c;
}
int main()
{
int ret = Add(1, 2);
cout << "ret = " << ret << endl;//3
return 0;
} 
假设用传引用返回
引用返回的含义：不会生成c的拷贝返回,直接返回c的引用
传值返回：
返回对象会拷贝给临时对象,临时对象做返回,现在用传引用返回,返回的是返回对象的引用(别名)
int& Add(int x, int y)
{
int c = x + y;
return c;
}
int main()
{
int ret = Add(1, 2);
cout << "ret = " << ret << endl;
} 
当前代码的问题：
- 1.存在非法方法,因为Add函数返回的值是c的引用,所以Add函数栈帧销毁之后,会去访问c位置的空间取值
- 2.如果Add函数栈帧销毁,清理空间,那么取c的值的时候就是随机值,给ret的就是随机值,这个取决于编译器的实现
- 如果后序没有新的函数栈帧开辟或者新的函数栈帧不足以覆盖c的内容,得到的还是c的值,否则就是随机值
tmp是c的别名,相当于返回c的引用,如果c的空间被清掉,c的值变成随机值,ret的值就会是随机值
如：后面的函数栈帧把原来c的空间被覆盖了
int& Add(int x,int y)
{
int c = x + y;
return c;
}
int main()
{
int& ret = Add(1,2);//ret也是c的引用
cout << "ret = " <<ret << endl;
printf("11111\n");
cout << "ret = " << ret << endl;
return 0;
} 
注意:此时ret也是c的引用
printf也是函数,会把原来c变量空间的栈帧覆盖,导致ret的值为随机值
==注意==：如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已经还给系统了,则必须使用传值返回,
返回引用的话效率高 不用创建临时变量 只要返回的实体不会随着函数结束而销毁的话 都可以以引用的方式返回
通俗点说：就是出了作用域,变量还在的,就可以用引用的方式,可以提高效率
例子1：static的变量
//传引用返回
int& Count()
{
//n放在静态区,出了函数栈帧也不销毁,所以可以使用传引用返回
static int n = 0;
n++;
return n;
}
int main()
{
int a = Count();
cout << "a = " << a << endl; //1
a = Count();
cout << "a = " << a << endl; //2
return 0;
} 例子2：
//传引用返回
char& func(char* str, int i)
{
return str[i];
}
int main()
{
char arr[10] = "Mango";
char c = func(arr, 3);
cout << "c = " << c << endl;//g
c = func(arr, 2);
cout << "c = " << c << endl;//n
} 出了作用域,str[i]的空间没有被销毁,所以可以用传引用返回,str[i]这个是数组的空间, str[i]不是局部变量 局部变量str指针是在func函数中创建的,出了作用域就销毁
例子3
//方式1： ok
int& fun()
{
int* p =(int*)malloc(sizeof(int));
return *p;
}
//方式2： err
int*& fun()
{
int* p =(int*)malloc(sizeof(int));
return p;
} 方式1是正确的,方式2是错误的！
原因：p是局部变量,出了作用域就销毁了,但是*p(malloc出来的空间还在),所以 return *p可以,return p 不可以
例子4：用引用返回实现可读可写
#define N 5
int& func(int i)
{
static int a[N];
return a[i];//返回的是a[i]的别名
}
int main()
{
//读
for (size_t i = 0; i < N; i++)
{
//func[i]返回的是a[i]的别名
//相当于a[i] = i + 1
func(i) = 1 + i;
}
//写
for (size_t i = 0;i < N;i++)
{
//func[i]返回的是a[i]的别名
//相当于打印a[i]对应的值
cout << func(i) << " " ; // 1 2 3 4 5
}
return 0;
} ==注意==：若把引用取消就会报错
原因：此时是值返回,会生成一个临时变量,返回的是a[i]的临时变量,临时变量具有常性(是右值:不可以被修改)
右值：表达式的返回值,常量,可以认为是右值, 右值的特点：右值不能被修改,如果引用一个一直,要用const修饰
普通引用引的就是左值,const引用引的是右值
例子1：
例子2：
例子3:表达式的返回值也是右值
int x1 = 1; int x2 = 2; int& r = x1+x2;
所以要写成：
const int& r = x1+x2;
传值,传引用的效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,
因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低
测试代码
//传值传参和传引用传参的效率对比
#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;//a的大小为4W字节
// 值返回 - 传值返回都会生成临时变量(临时拷贝),每次拷贝4W字节
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;
} 传值和指针在作为传参以及返回值类型上效率相差很大,
==总结：==引用的作用主要体现在传参和传返回值
1.引用传参和传返回值,有些场景下面,可以提高性能(大对象+ 深拷贝对象)
2.引用传参和传返回值,输出型参数和输出型返回值,通俗来说,有些场景下,形参的改变可以改变形参（传引用,二者占用同一块空间）,有些场景下,引用返回,可以改变返回对象
不能返回栈空间上的引用
传值,传地址,传引用的效率比较
引用>地址>值
引用和指针的区别
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间
在底层实现上实际是有空间的,因为引用是按照指针方式来实现的,
- 引用和指针的汇编代码对比
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
} 
结论
引用和指针的不同点:
引用概念上定义一个变量的别名(没有开辟空间),指针存储一个变量的地址
引用在定义时必须初始化,指针没有要求
引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型
实体没有NULL引用,但有NULL指针
在sizeof中含义不同：引用结果为引用变量类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节,64位平台下占8个字节)
int a = 0; int& b = a; sizeof(b) ? ==> sizeof(b) == sizeof(a) == sizeof(int) char c ='a'; char&d = c; sizeof(d) -> sizeof(c) == sizeof(char) = 1
- 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全
相同点
底层的实现方式相同,都是按指针的方式实现
第一条汇编：把1放到a空间, 后面的汇编都是一样的:取出a的地址放在寄存器eax中,把eax寄存器的值放到b变量中
引用的本质： 通过指针常量取实现
int a=10; int &ref=a;//int *const ref =&a; *修饰的是ref,ref的指向不可以改变,但是*ref可以 ref=20;
如果要连续定义指针/引用,每个名字都需要以* / &开头
int a = 10; int& b = a,&c = a;//c前面的&不可省略,不然c就是个变量,相当于int c = a; //这个和指针也一样 int *a,b;//a是指针,b是变量 int*a,*b;//a,b都是指针
问：下面两个函数是否构成函数重载
void func(int* ps)
{
cout << " func(int* ps)" << endl;
}
void func(int& p)
{
cout << " func(int& p)" << endl;
}
int main()
{
int a = 10;
func(&a);
func(a);
} 二者构成函数重载,指针和引用是不同的类型,
指针使用更复杂,更容易出错
void f1(int* ps)
{
*ps = 10;
}
void f2(int& p)
{
p = 10;
}
int main()
{
int a = 10;
//正常传参
f1(&a);
f2(a);
//引起f1程序崩溃的方法
f1(NULL);
f1(0);
//但是如果按上述方式传给f2-直接报错,在编译层就检查出来了
f2(NULL);
f2(0);
return 0;
} 使用指针要考虑空指针,野指针等等问题,指针太灵活了,所以相对而言,没有引用安全
相同类型之间赋值不会产生临时变量,不同类型转化赋值会产生临时变量,临时变量具有常属性
int a = 10; int b = a;//不会产生临时变量 double d = a;//会产生临时变量
函数返回值,表达式会产生临时变量
int a = 10;
int b = 5;
int c = a+b;//会产生临时变量
int test()
{
int a = 10;
return a;//会产生临时变量
} 注意:指针的引用
int main()
{
int a = 10;
int* p = &a;
const int*& refp = p;
cout << *refp << endl;
return 0;
} 上述代码refp是指针p的引用,并且可读可写变成了只读,权限缩小,看起来是没有任何问题,但是实际上,会报错:
- 无法从int* 转化为const int &*
原因: 主要是指针不能使用常引用, 如果是常引用的话，指针类型是不匹配的, 这个跟引用其它变量是有区别的,指针的引用必须要完全类型匹配
解决办法: 把const去掉
int main()
{
int a = 10;
int* p = &a;
int*& refp = p;
cout << *refp << endl;
return 0;
} 如果是函数: bool operator()(const ListNode*& left,const ListNode*& right)
此时就有两种解决方法:
- 一个是把指针的引用去掉
- 另一个是把const去掉
投递蚂蚁集团等公司10个岗位