注册一个网站多少钱?关键词快速排名seo怎么优化
引用的概念
引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会因为引用变量而开辟内存空间，它和它引用的变量公用同一块空间。
相当于是给被引用的变量取了一个小名，但是相当于是同一个变量。
类型& 引用变量名（对象名） = 引用实体
void TestRef()
{
int a = 10;
int& ra = a;// 定义引用类型
printf("%p\n",&a);
printf("%p\n",&ra);
}
注意：引用类型必须和引用实体是同种类型的数据。
对引用变量的修改就是对引用实体的修改
这里可以对输出型参数进行应用
1.交换函数
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 10, b = 20;
Swap(a,b);
cout << "a = " << a << endl << "b = " << b;
}
2.单链表
本来，对于单链表的pushback而言，我们要传入二级指针
typedef struct SListNode
{
SLDataType data;
struct SListNode* next;
}SLnode;
void SLPushBack(SLNode** pphead, SLDateType x)
{
SLNode** pphead, SLDateType x;
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
SLNode* tail = *pphead;
while(tail -> next != NULL)
{
tail = tail -> next;
}
tail -> next = newnode;
}
}
有了引用，我们就可以这样写
typedef struct SListNode
{
SLDataType data;
struct SListNode* next;
}SLnode;
void SLPushBack(SLNode*& phead, SLDateType x)
{
if (phead == NULL)
{
phead = newnode;
}
else
{
SLNode* tail = phead;
while(tail -> next != NULL)
{
tail = tail -> next;
}
tail -> next = newnode;
}
}
引用特性
1.引用在定义时必须初始化
void TestRef()
{
int a = 10;
// int&ra ；//该条语句编译时会出错
int& ra = a;
int& rra = a;
}
2.一个变量可以有多个引用
还可以给别名再取别名，这样，所有的名字其实都指的是同一个变量。
3.引用一旦引用一个实体，再不能引用其他的实体
常引用
void TestConstRef()
{
const int a = 10;
//int& ra = a; //该语句编译时会出错，因为a为常量
const int& ra = a;
//int& b = 10; //该句编译时会出错，因为b为常量
const int& b = 10;
double b = 12.34;
//int& rd = d; //该语句编译时会出错，因为类型不同
const int& rd = d;
}
做返回值
正常情况下的传值返回：
int Count()
{
int n = 0;
n++;
return n;
}
int main()
{
int ret = Count();
cout << ret << endl;
}
如果将代码改成
int& Count()
{
int n = 0;
n++;
return n;
}
int main()
{
int ret = Count();
cout << ret << endl;
cout << ret << endl;
}
此时，相当于是Count函数的返回值是n的一个引用
虽然短期内可以返回正确的值
但是，我们知道，出了Count函数后，n变量就会被销毁，此时我们利用它的引用取访问它，其实就相当于之前的野指针问题，会有很大的安全问题。
如果将代码再改成下面的情况：
int& Count()
{
int n = 0;
n++;
return n;
}
int main()
{
int& ret = Count();
cout << ret << endl;
cout << ret << endl;
}
相当于ret和返回值都是n这个变量
第二次访问的时候出现了随机值。
因为cout输出本身也是调用了函数，在Count函数调用完后，它的栈帧销毁了（其中也包括n的那块空间），紧接着cout开始调用函数，这时，cout调用的函数的栈帧就可能会将之间的Count所在的栈帧进行覆盖，同理，n所在的那块栈帧就可能会被各种值覆盖，因此，第二次通过n的引用访问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) = " << ret << endl;
return 0;
}
同样的道理，在不清栈帧的情况下，Add（1，2）函数执行的时候开辟的栈帧的c所在的空间，会被后面再次调用Add（3，4）时覆盖，得到7。
结论：
如果函数返回时，出了函数作用域，如果返回对象还在（还没还给系统），则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
什么情况下可以使用传引用返回
1.返回的变量是全局对象（这样出了函数，变量并不会被销毁）
2.返回的对象是静态对象
传引用传参的作用(任何时候都可以)
1.提高效率
2.输出型参数（形参的修改，影响的实参）
传引用返回的作用（出了函数作用域对象还在才能用）
1. 提高效率
2.可以修改返回对象：
小例：单链表的访问和修改：
单链表：
struct SepList
{
int *a;
int size;
int capacity;
};
c语言：
//访问第i个位置的值
int SLAT(struct SepList* ps, int i)
{
assert(i < ps->size);
return ps->a[i];
}
//将第i个位置的值修改为x
void SLModify(struct SepList* ps, int i, int x)
{
assert(i < ps-> size);
ps->a[i] = x;
}
c++引用：
//访问或修改第i个位置的值
int& STAT(struct SepList* ps, int i)
{
assert(i < ps -> size);
return ps->a[i];
}
此时，引用返回如果想要修改第i个位置的值,则直接修改即可，因为函数的返回是ps->a[i]的一个引用，所以此函数既可以访问，也可以修改。
STAT(ps,i) = 1;
在引用的过程中，权限可以平移，可以缩小，但不可以放大
小例：
int main()
{
const int a = 0;
//权限的放大：本来a变量不可以修改的，但是引用变量b是可以被修改的，所以这里不能这么写
int& b = a;
//权限的平移：这里b和a都不能被修改，所以权限是相同的，可以这样写
const int& b = a;
//权限的缩小：本来a是可以被修改的，但是引用变量b不可以，这样就会把a的权限缩小，但是这样是合法的
int a = 0;
const int& b = a;
return 0;
}
还有一种情况：
int a = 7;
double& b = a;
这样写也是会报错的：
因为int类型的变量赋值给double时，不是直接给的，中间会有一个double类型的临时变量，也就是隐式转换，先将int类型的a转换成double类型，赋值给临时变量，然后将这个临时变量的值给b。
而我们知道，临时变量具有常量性，所以如果这样写,会有权限放大的现象。
如果改为：
int a = 7;
const double& b = a;
就不会报错了。
类似的：
int fun()
{
int a = 0;
return a;
}
int main()
{
int& ret = fun();
return 0;
}
这里也会报错：
因为，fun函数不是直接返回a，而是返回a的一份临时拷贝，也是具有常量性，所以这里的int& ret = fun()也存在权限放大的问题。
但是改为const int& ret = fun()就可以了。
这里的临时变量也会因为这里的引用被自动延长生命周期，直到不再使用为止。
引用和指针的联系
从汇编角度来看，引用其实和指针在底层其实是一种操作，也就是说底层其实没有引用，只有指针。
执行++操作的步骤也是一样的。
引用和指针的区别
1.引用概念上定义一个变量的别名，指针存储了一个变量指针。
2.引用在定义时必须初始化，指针没有要求。
3.引用在初始化时引用一个实体后，就不能再引用其他实体了，而指针可以在任何一个同类型实体
4.没有NULL引用，但又NULL指针。
5.在sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节）
6.引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7.有多级指针，但是没有多级引用。
8.访问实体方式不同，指针需要显示解引用，引用编译器自己处理。
9.引用比指针使用起来相对更安全。