C++初阶引用

引用

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

比如周树人，在外的笔名叫鲁迅

类型& 引用变量名(对象名) = 引用实体；

int main()
{int a = 0;int& b = a; // 引用cout << &a << endl;cout << &b << endl;b++;a++;return 0;
}

在这里插入图片描述

引用的特性

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

int a = 0;
int& b = a
int x = 1;
// 赋值
b = x;

在这里插入图片描述
b还是和a的地址是一样的

使用输出型参数

二叉树的前序遍历

本题用c语言写的话：

void _preorderTraversal(struct TreeNode* root,int* a,int* pi)
{if(root==NULL)return NULL;a[(*pi)++]=root->val;_preorderTraversal(root->left,a,pi);_preorderTraversal(root->right,a,pi);
}

而c++用了引用后：

void _preorderTraversal(struct TreeNode* root, int* a, int& ri)
{if (root == NULL)return;printf("[%d] %d ", ri, root->val);a[ri] = root->val;++ri;_preorderTraversal(root->left, a, ri);_preorderTraversal(root->right, a, ri);
}//只放部分代码展示
int i = 0;
_preorderTraversal(root, a, i);

为什么不是直接传值(如图)：
在这里插入图片描述
使用交换函数的使用也会方便许多

void swap(int& x1, int& x2)
{int tmp = x1;x1 = x2;x2 = tmp;
}
int main()
{int x = 0, y = 1;swap(x, y);return 0;
}

以前学习单链表尾插的时候

c语言二级指针的玩法

void PushBack(ListNode** pphead, int x)
{ListNode* newnode;if (*pphead == NULL){*pphead = newnode;}else{}
}int main()
{ListNode* plist = NULL;PushBack(&plist, 1);PushBack(&plist, 2);PushBack(&plist, 3);return 0;
}

C++，引用的玩法

typedef struct ListNode {int val;struct ListNode* next;
}ListNode, *PListNode;void PushBack(ListNode*& phead, int x)
//void PushBack(PListNode& phead, int x) 和上面代码一样的
{ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));// ...if (phead == NULL){phead = newnode;}else{}
}int main()
{ListNode* plist = NULL;PushBack(plist, 1);PushBack(plist, 2);PushBack(plist, 3);return 0;
}

plistnode是对struct Listnode*的typedef，也就是指针的typedef。plistnode代表结构体指针

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

作返回值

在这里插入图片描述

不是把n返回给ret，因为函数调用结束的时候，n已经销毁了，所以不敢拿n去返回。所以设定是会生成临时变量，可能会用寄存器也可能是其他方式。在返回前拷贝给临时变量。把n的值拷贝到寄存器，然后寄存器充当返回值，一般值小的时候。当n比较大的时候，会在栈帧中间部分提前压一块空间作返回值。

还有一种返回方式叫传引用返回
返回的是n的引用，也就是返回的是n
可能会出现问题，n销毁了还返回n的别名，类似于野指针
在这里插入图片描述

int& Count()
{int n = 0;n++;// ...return n;
}int main()
{int ret = Count();cout << ret << endl;cout << ret << endl;return 0;
}

打印的结果可能是1，也可能是随机值，取决于这个栈帧销毁后空间会不会被置成随机值，得看环境，在vs下的结果是1 1

来看下面的代码会造成什么不一样的情况：

int& Count()
{int n = 0;n++;// ...return n;
}int main()
{int& ret = Count();cout << ret << endl;cout << ret << endl;return 0;
}

在这里插入图片描述

cout<<ret是一个函数调用，流插入这个函数调用还是在count空间上，只是栈帧大小可能比count大或小，函数调用时定义一些变量的时候就会对比如原来n的位置进行覆盖。

第一次调用没有覆盖因为调用函数先传参。传参过去之后函数建立栈帧但是传的值不会受到影响。第二次调用的时候想去取值，就会发现值被覆盖了。

不一定会覆盖，如果变量定义在太前一般都会被覆盖。比如在n前面定义一个大的数组就可能不被覆盖了。那么两次打印结果就都为1了(vs下)。

int& Count()
{int a[1000];int n = 0;n++;return n;
}

再看一个情况

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

可能是随机值可能是7，看栈帧销毁后空间会不会被置成随机值。

传引用返回让代码优化的例子：

C的接口设计
读取第i个位置的值
int SLAT(struct SeqList* ps, int i)
{assert(i < ps->size);// ...return ps->a[i];
}
修改第i个位置的值
void SLModify(struct SeqList* ps, int i, int x)
{assert(i < ps->size);// ...ps->a[i] = x;
}CPP接口设计
读 or 修改第i个位置的值
int& SLAT(struct SeqList& ps, int i)
{assert(i < ps.size);// ...return (ps.a[i]);
}int main()
{struct SeqList s;s.size = 3;// ...SLAT(s, 0) = 10;SLAT(s, 1) = 20;SLAT(s, 2) = 30;cout << SLAT(s, 0) << endl;cout << SLAT(s, 1) << endl;cout << SLAT(s, 2) << endl;return 0;
}

小总结

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

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

传引用传参（任何时候都可以用）
1、提高效率
2、输出型参数（形参的修改，影响的实参）

传引用返回（出了函数作用域对象还在才可以用）
1、提高效率
2、修改返回对象

引用的权限

在引用的过程中
权限可以平移
权限可以缩小
权限不能放大

int func()
{int a = 0;return a;
}int main()
{const int& ret = func();const int a = 0;// 权限的放大// int& b = a;//int b = a; 可以的，因为这里是赋值拷贝，b修改不影响a// 权限的平移const int& c = a;// 权限的缩小int x = 0;const int& y = x;//x更改y也会改，y不能更改int i = 0;const double& d = i;return 0;
}