6. 引用

6.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

类型& 引用变量名(对象名) = 引用实体；
#include
using namespace std;int main()
{int a = 0;int& b = a;//定义引用类型cout << &a << endl;//取地址cout << &b << endl;//取地址//地址相同a++;cout << a << endl;//1cout << b << endl;//1b++;cout << a << endl;//2cout << b << endl;//2return 0;
}
注意：引用类型必须和引用实体是同种类型的

6.2 引用特性

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

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

#include
using namespace std;int main()
{int a = 10;int& b = a;int& c = a;int& d = c;int& ra = a;int& rra = a;cout << &a << ' ' << &ra << ' ' << &rra << endl;//地址相同//引用一旦引用了一个实体，在不能引用其他实体int x = 50;b = x;//此时b 不是x的别名，而是赋值给bcout << b << endl;return 0;
}

6.3 常引用

//常引用
#include
using namespace std;
int main()
{int a = 10;int& b = a;cout << typeid(a).name() << endl;cout << typeid(b).name() << endl;const int c = 20;//c的权限被修改，权限放大//int& d = c; //errconst int& d = c;int const&  e = c;//权限缩小，e以只读的方式取别名f，f只能读，不能改int f = 30;const int& g = f;int ii = 1;double dd = ii;//double& rdd = (double)ii;//errconst double& rdd = ii;//如上图分析const int& x = 10;//引用一个常量，对常量起别名return 0;//由上可知，权限不能放大，但是可以缩小
}

所有类型的提升、转换或强转，并不会改变原变量的类型，而是中间产生一个临时变量

void func1(int n)
{}
//如果使用引用传参，函数内如果不改变n，那么建议尽量用const引用传参
//void func2(int& n)
void func2(const int& n)
{}void func3(int* n)
{}
int main()
{//使用引用可以传多种类型的变量int a = 10;const int b = 20;func1(a);func1(b);func1(30);func2(a);//sucessfunc2(b);//err,涉及权限放大,const引用传参正确func2(30);//err,涉及权限放大，const引用传参正确int* c = &a;func3(&a);func3(c);//func3(&b);//err,传递的是const int* ，而函数是 int*//只有引用才涉及权限放大问题，同样指针也涉及权限放大问题//而 func1 函数穿的只是一份临时拷贝，并不会影响原数据return 0;
}

6.4 使用场景

引用的使用场景：

1.做参数—— a. 输出型参数 b. 大对象传参，提高效率

2. 做返回值—— a. 输出型返回对象，调用者可以修改返回对象 b. 减少拷贝，提高效率

1. 做参数——输出型参数

#include
using namespace std;
//1.做参数————输出型参数
void Swap(int& left, int& right)
{int temp = left;left = right;right = temp;
}typedef struct SeqList
{//...
}SL;
void SLPushBack(SL& s, int x)
{}//原 1
//typedef struct SListNode
//{
//	//..
//}SLTNode;
//
//void SListPushBack(SLTNode** pphead, int x)
//{
//
//}优化 1
//typedef struct SListNode
//{
//	//..
//}SLTNode;
//
//void SListPushBack(SLTNode*& pphead, int x)
//{
//
//}//优化 2
typedef struct SListNode
{//..
}SLTNode,*PSLTNode;void SListPushBack(PSLTNode& pphead, int x)
{}int main()
{int a = 1, b = 2;Swap(a, b);cout << "a = " << a << endl << "b = " << b << endl;SL sl;SLPushBack(sl, 1);SLPushBack(sl, 1);SLPushBack(sl, 1);SLPushBack(sl, 1);//SLTNode* list = NULL;//SListPushBack(&list, 1);//SListPushBack(&list, 2);//SListPushBack(&list, 3);//SLTNode* list = NULL;//SListPushBack(list, 1);//SListPushBack(list, 2);//SListPushBack(list, 3);PSLTNode list = NULL;SListPushBack(list, 1);SListPushBack(list, 2);SListPushBack(list, 3);return 0;
}

2. 做返回值——传引用返回的具体使用

//传值返回——--都会生成一个临时拷贝对象，返回该值// 由函数栈帧可知，当函数执行完，就会销毁，而返回值有以下两种情况
// 当返回值不大的时候，会用寄存器保存返回值
// 当返回值过大的时候，会提前在main函数开辟好存储返回值的空间进行返回
//int Count1()
//{
//	int n = 0;
//	n++;
//	//...
//	return n;
//}//这里的返回值由于是放在静态区的静态变量，因此当函数栈帧结束
//返回值n不后销毁，但是编译器仍像上述生成一临时拷贝区
int Count1()
{static int n = 0;n++;//...return n;
}

//2.传引用返回————就是返回其返回值的别名
#include
using namespace std;
int& Count()
{int n = 0;n++;//...return n;
}int main()
{int ret = Count();//此时函数调用完，反会值销毁，为什么还会返回 1 ？//可知，销毁后，虽然越界了，但是进行访问是可以的//这里的ret 为 1 是侥幸cout << ret << endl;//1//引用返回的语法含义是返回返回对象的别名//ret 的结果是未定义的//如果栈帧结束时，系统会清理栈帧置成随机值，那么这里的ret的结果就是随机值//上面程序使用引用返回本质是不对的，结果是不会有保证的return 0;
}

总结：如果出了函数的作用域，返回对象就销毁了，那么一定不能用引用返回，一定要用传值返回。

//2.传引用返回————就是返回其返回值的别名
//此场景才会使用传引用返回
#include
using namespace std;
int& Count()
{static int n = 0;n++;//...return n;
}int main()
{int ret = Count();int& tmp = Count();cout << ret << endl;//1//static修饰的变量存在静态区，因此n这块空间不会销毁cout << tmp << endl;//2return 0;
}

传引用返回的具体使用——修改：

SeqList.h

#pragma once
#include
#includenamespace SeqList
{typedef int SLDataType;typedef struct SeqList{SLDataType* _a;int _size;int _capacity;}SL;void SLInit(SL& s, int capacity = 4);void SLPushBack(SL& s, SLDataType x);//修改数据的函数//void SLModify(SL& s,int pos,SLDataType x);SLDataType& SLAt(SL& s, int pos);
}

SeqList.cpp

#include"SeqList.h"void SeqList::SLInit(SL& s, int capacity)
{s._a = (SLDataType*)malloc(sizeof(SLDataType*) * capacity);assert(s._a);s._size = 0;s._capacity = capacity;
}void SeqList::SLPushBack(SL& s, SLDataType x)
{// ...s._a[s._size] = x;s._size++;
}int& SeqList::SLAt(SL& s, int pos)
{assert(pos >= 0 && pos <= s._size);return s._a[pos];
}

SeqListTest.cpp

#include"SeqList.h"
using namespace std;
using namespace SeqList;int main()
{SL sl;SLInit(sl);SLPushBack(sl, 1);SLPushBack(sl, 2);SLPushBack(sl, 3);SLPushBack(sl, 4);SLAt(sl, 0)++;for (int i = 0; i < sl._size; i++){cout << sl._a[i] << " ";}cout << endl;SLAt(sl, 0) = 10;for (int i = 0; i < sl._size; i++){cout << sl._a[i] << " ";}cout << endl;return 0;
}

6.5 传值、传引用

6.5.1 传值和传引用效率比较

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

//大对象传参，提高效率
#include
using namespace std;#include 
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;//12mscout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;//0ms
}int main()
{TestRefAndValue();return 0;
}

6.5.2 值和引用的作为返回值类型的性能比较

#include
using namespace std;
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;//194mscout << "TestFunc2 time:" << end2 - begin2 << endl;//3ms
}int main()
{TestReturnByRefOrValue();return 0;
}

通过上述代码的比较，发现传值和传引用在作为传参以及返回值类型上效率相差很大。

6.6 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
int main()
{int a = 10;int& ra = a;cout << "&a = " << &a << endl;cout << "&ra = " << &ra << endl;return 0;
}
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
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. 指针更强大，更危险，更复杂，而引用相对局限一些，比指针使用起来相对更安全，更简单

10.从语法的角度，引用没有开辟空间，指针开了4/8字节空间，而从上图反汇编，从底层实现角度分析，引用底层使用指针实现的。可以理解为引用是指针的封装。

数据结构，链表初始化，不能够使用引用，1.因为引用定义时必须初始化，2.因为引用不能改变指向，参考上面第三条，而指针可以改变指向