【C++入门】引用

6.引用

6.1引用概念

6.2引用的写法

6.3引用的特性

6.4常引用

6.5引用的使用场景

6.5.1引用做参数

6.5.2引用做返回值❗❗

🎇值做返回值

🎇引用做返回值

🎇引用在顺序表做返回值

6.5.3传值、传引用效率比较(参数）

6.5.4值和引用的作为返回值类型的性能比较（返回值）

6.6引用和指针

6.6.1引用替换指针的场景

6.6.2引用和指针的区别

6.引用

6.1引用概念

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

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

6.2引用的写法

引用的写法格式：

类型& 引用变量名(对象名) = 引用实体；
可以给变量的别名取别名，所有别名都是公用同一块内存空间。
注意：引用类型必须和引用实体是同种类型的

//类型& 引用变量名(对象名) = 引用实体;
void TestRef()
{int a = 10;int& ra = a;//<====定义引用类型printf("%p\n", &a);printf("%p\n", &ra);
}

【验证变量和变量的引用（别名）是否是同一块内存空间】

#include<iostream>
using namespace std;int main()
{int a = 0;int& b = a;int c = a;cout << &a << endl;cout << &b << endl;cout << &c << endl;cout << b << endl;cout << c << endl;b++;//b++的同时a++了吗？c++了吗？cout << a << endl;cout << b << endl;cout << c << endl;return 0;
}

【别名的别名&类型一致原则】

int main()
{int a = 0;int& b = a;int& c = b;cout << &a << endl;cout << &b << endl;cout << &c << endl;//❌double& b=a;类型必须一致return 0;
}

6.3引用的特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

大家可以自己动手验证下。

int main()
{int a = 0;//1.引用必须初始化//int& b;//b = a;//2.引用定义后，不能改变指向int& b = a;int c = 2;b = c;//这是不是改变指向，而是赋值cout << a << endl;//2cout << b << endl;//2//3.一个变量可以有多个引用，多个别名//定义别名的别名int& x = a;int& d = c;return 0;
}

6.4常引用

void TestConstRef()
{const int a = 10;//int& ra = a;   // 该语句编译时会出错，a为常量const int& ra = a;// int& b = 10; // 该语句编译时会出错，b为常量const int& b = 10;double d = 12.34;//int& rd = d; // 该语句编译时会出错，类型不同const int& rd = d;
}

6.5引用的使用场景

6.5.1引用做参数

引用做参数：

输出型参数
输入型参数
对象比较大，减少拷贝，提高效率
指针可以做，但是引用的更方便，更有性价比

//输出型参数
int* preorderTraversal(struct TreeNode* root, int* returnSize)
int* preorderTraversal(struct TreeNode* root, int& returnSize)


//交换两个变量#include<iostream>
using namespace std;void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
int main()
{int x = 10;int y = 20;cout << "x=" << x << endl;cout << "y=" << y << endl;Swap(&x, &y);cout << "x=" << x << endl;cout << "y=" << y << endl;return 0;
}void Swap(int& p1, int& p2)
{int tmp = p1;p1 = p2;p2 = tmp;
}
int main()
{int x = 10;int y = 20;cout << "x=" << x << endl;cout << "y=" << y << endl;Swap(x, y);cout << "x=" << x << endl;cout << "y=" << y << endl;return 0;
}
//不能交换地址

6.5.2引用做返回值❗❗

🎇值做返回值

请问return a意味着把a的值传给func吗？回顾：函数栈帧的创建与销毁-CSDN博客

函数调用结束，函数栈帧就销毁了，return需要返回值，会再函数栈帧销毁之前拷贝放到临时空间里面。给ret接收。
数据小，临时空间是寄存器。数据大。

#include<iostream>
using namespace std;
int func()
{int a = 0;return a;
}int main()
{int ret = func();return 0;
}

🎇引用做返回值

函数调用结束，函数栈帧就销毁了，return返回a的别名，给ret接收。
ret接收到了之后，后面访问a的别名，也就是访问a的空间，但是a的空间已被销毁，就会造成非法访问，野引用的问题。非法访问！！！特别注意

如果a的内存空间在函数调用之后没有被清理，去访问可能访问到原值。但是如果后序定义其他的变量，这个内存位置可能就被操作系统分配给其他的变量。
如果a的内存空间在函数调用之后被清理了，访问到了随机值。

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
返回变量出了函数作用域就生命周期（局部变量），不能用引用返回。返回变量出了函数作用域就生命周期到了就销毁，不能用引用返回。
非法访问！！野引用！！对程序存在安全隐患。
C++中临时变量具有常量（不可被修改）
全局变量/静态变量static/堆上变量等就可以引用做返回值。

【示例一】

#include<iostream>
using namespace std;
int& func()
{int a = 0;//✔static int a=0;return a;
}int main()
{int ret = func();return 0;
}

【示例二】

int& Add(int a, int b)
{int c = a + b;return c;
}
int main()
{int& ret = Add(1, 2);Add(3, 4);cout << "Add(1, 2) is :"<< ret <<endl;return 0;
}

🎇引用在顺序表做返回值

不需要typedef 就可以直接使用SeqList
结构体（类）中可以包含成员函数
域不同，不用再区分名称
开辟的空间在堆上，出了作用域，函数栈帧没有销毁（可以用引用做返回值）

返回引用

引用具有了读写双重功能
引用中间没有产生临时变量

引用做返回值

修改返回对象
减少拷贝提高效率

这个部分到后面还会细讲

//C++
#include<iostream>
#include<assert.h>
using namespace std;
struct SeqList
{//成员变量int* a;int size;int capacity;//成员函数void Init(){a = (int*)malloc(sizeof(int) * 4);// ...size = 0;capacity = 4;}void PushBack(int x){//... 扩容a[size++] = x;}//读写返回变量int& Get(int pos){assert(pos >= 0);assert(pos < size);return a[pos];}int& operator[](int pos){assert(pos >= 0);assert(pos < size);return a[pos];}
};int main()
{SeqList s;s.Init();s.PushBack(1);s.PushBack(2);s.PushBack(3);s.PushBack(4);for (int i = 0; i < s.size; i++){//cout << s.Get(i)<< " ";cout << s[i] << " ";//cout << s.operator[](i) << " ";}cout << endl;for (int i = 0; i < s.size; i++){/*if (s.Get(i) % 2 == 0){s.Get(i) *= 2;}*/if (s[i] % 2 == 0){s[i] *= 2;}}cout << endl;for (int i = 0; i < s.size; i++){cout << s.Get(i) << " ";}cout << endl;return 0;
}

6.5.3传值、传引用效率比较(参数）

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

clock只能计算出整数位。0ms表示小于1ms，不代表没有，代表时间极其短。

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void main()
{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;
}

6.5.4值和引用的作为返回值类型的性能比较（返回值）

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

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void main()
{// 以值作为函数的返回值类型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;
}

6.6引用和指针

6.6.1引用替换指针的场景

指针和引用的功能是类似的，重叠的。
C++的引用，对指针使用比较复杂的场景进行一些替换【场景替换】，让代码更简单易懂，但是不能完全替代指针。
C++的引用不能完全替代指针的元婴就有：引用定义之后，不能改变指向，但是指针可以改变指向。
在Java python 等其他语言里没有指正，只有引用，且其他语言的引用是可以改变指向的实现链表等。注意区别C++的引用是不能改变指向的。
C++中90%的场景还是使用引用，但是在一些特殊场景，我们还是使用指针。（例如：链表，二叉树，指向一段动态内存开辟的空间）

【链表中二级指针】

//双向无头链表
typedef struct Node
{struct Node* next;struct Node* prev;int val;
}LNode,*PNode;//void PushBack(PNode* phead, int x)
void PushBack(PNode& phead, int x)
{//
}
int main()
{PNode pphead;PushBack(pphead, 1);
}

【输出型参数】

OJ输入型参数：直接给数据使用。

OJ输出型参数：给参数需要修改这个参数（指针/别名）

int* preorderTraversal(struct TreeNode* root, int* returnSize)
int* preorderTraversal(struct TreeNode* root, int& returnSize)

6.6.2引用和指针的区别

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
9. 引用比指针使用起来相对更安全。
底层是底层，语法是语法，二者不可混为一谈。

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

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;
}

引用和指针的区别：

【语法】

引用是别名，不开空间；指针是地址，需要开空间存地址。
引用必须初始化，指针可以初始化可以不用初始化。
引用不能改变指向，指针可以改变指向。
引用相对更加安全，没有空引用；但有空指针。
容易出现野指针；但不容易出现野引用。
其他方面。

【底层】

汇编层面上，没有引用，只有指针，引用编译后也转换成指针了。

🙂感谢大家的阅读，若有错误和不足，欢迎指正。