C++修炼之练气期第五层——引用

目录

1.引用的概念

2.引用的性质

3.常量引用

4.使用场景

1.作参数

2.作返回值

5.传值与传引用的效率比较 

6.值和引用作为返回值的性能比较 

7.引用与指针

指针与引用的不同点

---

要说C语言中哪个知识点最难学难懂，大部分人可能和我一样的答案——指针。C++既然是C语言的豪华升级版肯定要优化这一问题。不过指针虽然难，但是不得不说它确实牛*呀，指针使C语言变得更加灵活更加万能，可以说指针是C/C++的精髓，因此取缔指针是万万不能的，所以C++的祖师爷引进了引用的概念。

1.引用的概念

引用：给已经存在的变量取个别名；编译器不会为引用变量开辟新的内存空间，它和引用的变量共用同一块内存空间；

例如：小明的小名叫作明明，不管是“明明”还是“小明”都指的是同一个人；

格式：类型& 引用变量名 = 被引用的实体；

//例如 ra 为 a 的引用
int a = 0;
int& ra = a;

比较一下两个变量的地址是否相同；

//比较二者的地址
cout << &a << endl;
cout << &ra << endl;

2.引用的性质

1.引用变量的类型与引用实体的类型要相同；

int a = 0;
int& ra = a;char ch = 'a';
char& rch = ch;

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

int a = 0;
int& ra = a; 
//int& ra;    //错误的写法

3.一个变量可以有多个引用；

int a = 0;
int& b = a;
int& c = a;
//...

4.引用变量只能引用一个实体。

int a = 0;
int b = 0;int& ra = a;
ra = b;   //不能再引用其他变量
//对比指针
int* pa = &a;
pa = &b;

3.常量引用

引用常量时记得用 const 修饰，因为指针、引用在赋值或初始化时，权限可以缩小不能放大。

//1.
const int a = 0;
//int& ra = a;		//编译时会报错，a为常量//权限放大
const int& ra = a;  //权限保持//int& b = 10;		//错误写法，10为常量//权限放大int c = 0;
const int& rc = c;  //权限缩小//2.
int Count()
{int a = 0;return a + 1;
}int main()
{//int& ret = Count();  //编译错误，Count 返回值为常量const int& ret = Count();return 0;
}//3.
int a = 0;
//double& b = a;    //类型错误
//double& b = (double)a;    //编译错误，类型转换时会产生临时变量
const double& b = (double)a;    //证明产生的临时变量具有常量性质

4.使用场景

目前看来，引用好像并没有什么用，接下来看一下引用经常用到的场景。

1.作参数

//形参的改变会影响实参，因为形参为实参的别名
void Swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}//对比指针
void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}

//顺序表
typedef struct SeqList
{int* a;int size;int capacity;
}SL;void SLPushBack(SL* ps, int data);//C语言中void SLpushBack(SL& rs, int data);//C++中

//单链表
typedef struct Node
{int data;struct Node* next;}Node,*PNode;void SLTPushBack(Node** pphead, int data);//C语言中void SLTPushBack(Node*& phead, int data);//C++中
void SLTPushBack(PNode& phead, int data);//C++中

2.作返回值

引用作返回值时，如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

int& Count()
{static int n = 0;//出了作用域并未销毁，可用引用返回n++;return n;
}

int& Add(int a, int b)
{int c = a + b;//c出了作用域会被销毁，引用返回不可用return c;
}int main()
{int& ret = Add(1, 2);Add(3, 4);cout << "Add(1, 2) is :" << ret << endl;//看似结果为3，实则不然return 0;
}

引用作函数返回值时，调用函数时可修改返回对象；

#include<assert.h>
#define N 10typedef struct Array {int a[N];int size = N;
}Array;int& Test(Array& a, int i)
{assert(i < N);return a.a[i];
}int main()
{Array a;for (int i = 0; i < N; i++){Test(a, i) = i * 10;}for (int i = 0; i < N; i++){cout << Test(a, i) << " ";}cout << endl;return 0;
}

5.传值与传引用的效率比较 

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

//一组测试代码
#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;
}

6.值和引用作为返回值的性能比较 

//一组测试代码
#include <time.h>
struct A 
{ int a[10000]; 
};A a;
// 值返回
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;
}
int main()
{TestReturnByRefOrValue();return 0;
}

7.引用与指针

引用与指针的用法及原理在我们使用者看来是不相同的（引用是给变量取别名，指针是指向变量的地址），但是其实引用的底层实现就是以指针的方式实现的。例如：

int main()
{int a = 10;int& ra = a;ra = 20;int* pa = &a;*pa = 20;return 0;
}

对比一下指针与引用的汇编代码，发现二者完全相同。

那么既然底层实现相同，我们是不是就不用区别引用和指针了呢？当然不是，底层实现相同可不关咱们使用者什么事，在使用时我们依旧要注意二者的区别。

指针与引用的不同点

1. 引用概念上定义一个变量的别名，指针存储一个变量地址；

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

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

4. 没有 NULL 引用，但有 NULL 指针；

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

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

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

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

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