c++：引用原理详解_c++ 引用原理-CSDN博客

本文链接：https://blog.csdn.net/W_J_F_/article/details/81488937

引用原理详解：

什么是引用变量？

对一个数据建立“引用”，它的作用是为一个变量起一个别名。

类型&引用变量名 = 引用实体

int a;      //定义a是整形变量
int &b = a; //声明b是a的引用

以上声明了b是a的引用，即b是a的别名。a或b作用相同，都代表同意变量。可以这样理解：通过b引用a。&是引用声明符，并不代表取地址。在数据类型名后面出现的&是引用声明符，在其他场合都是地址符。

char &d = c;//引用声明
int *p = &a;//地址符

编译器不会为引用变量开辟内存空间，而是变量和它的引用共用一块空间。

引用要点分析：

1：引用不是一种独立的数据类型。对引用只有声明，没有定义。必须先定义一个变量，然后声明对该变量建立一个引用。

2：声明一个引用时，必须同时使之初始化，即声明它代表哪一个变量。当引用作为函数形参时不必在声明中初始化，他的初始化是在调用函数时的虚实结合实现的，即作为形参的引用是实参的别名

3：在声的别名引用之后，不能在使之作为另一个变量的引用。

声明了b是a的引用后，在其有效范围内，b始终与其代表的变量a相联系，不能用做其他变量引用

4：不能建立引用数组。

int a[5] ;

int &b[5] = a;//错误，不能建立引用数组

int &b = a[0]; //错误，不能作为数组元素的别名

5：不能建立引用的引用，也没有引用的指针

不能建立引用的引用，也不能建立引用的指针

6：可以取引用的地址

如果以声明b是a的引用，&b和就是a的地址

7：区别引用声明符&和取地址符&

本质说明：

在程序中声明了b是a的引用，实际上在内存中开辟了一个指针型的储存单元，在其中放变量a的地址，输出引用b时，就输出b所指向的变量a的值，相当于*b.引用其实就是一个指针变量，它的指针不能改变，只能指向一个指定的变量。所以引用的本质还是指针。

数组的引用和引用数组:

从运行结果中可以看到b的大小和数组a的大小一样，也为20。

将int (&b)[5] = a; 改为 int &b[5] = a;则编译无法通过，因为声明了一个引用数组。

对上两图：

1：int(&b)[5] =  a;
()优先级高，先建立了引用，在对数组进行引用就是OK的
2：int &b[5]  =  a;
[]优先级高，先建立一个大小为5的数组，先用数组b引用a

即便你将引用数组b中的每一个元素b[i]看做对a[i]的引用，然后对每一个元素进行初始化，也是错误的：

 int &b[5] = {a[0],a[1],a[3],a[3],a[4]};

引用核心就是减少拷贝，如果使用引用时会造成额外的空间消耗就是错误的

总结：可以对整个数组引用，但你不能建立数组引用一个数组或创建一个元素都是引用的数组。（因为数组需要开辟额外空间存储数组内元素）

引用传参：

C语言中，函数传参有两种方式：

1：传值

void swap(int left,int right)
{
    int temp = left;
    left = right;
    right = tmp;
}

在函数调用的过程会生成一份临时变量，最终把实参的值传递给新分配的临时变量及形参。

优点：避免了函数调用副作用

缺点：无法改变形参的值

如果想通过形参改变实参，只能通过指针。

2：传址：

void swap(int *left,int *right)
{
   int temp = *pleft;
   *pleft = *pright;
   *pright = tmp;
}

指针可以解决问题，但是不友好，安全。

引用：

#include<iostream>
#include<stdlib.h>

using namespace std;

int main()
{
	void swap(int &,int &);//不必在声明中初始化
	int i = 1;
	int j = 3;
	swap(i,j);
	cout << "i = " << i << "  " << "j = " << j << endl;
	system("pause");
	return 0;
}

void swap(int &a,int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

引用作为返回值：

函数返回时，如果不是返回一个变量的引用，则一定会生成一个临时变量。

（1）以引用返回函数值，定义函数时需要在函数名前加 &

（2）用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。

int& at()
{
    return m_data_;
}

引用作为返回值，必须遵守以下规则：

（1）不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。
（2）不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。
（3）可以返回类成员的引用，但最好是const。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

常引用：

常引用作函数参数。这样既能保证数据安全，是数据不能被随意修改。

一：

    //变量初始化，const引用变量
    int b = 10;
    const int &a = b;
    b = 11;//b是可以修改的，但是a不能修改

a = b = 11；内容不能通过a修改，b可以修改。

二：

     //const引用常量
    const int &c = 100;
    //编译器会给常量100开辟一片内存，并将引用名作为这片内存的别名
    //int &d=100     //err

给常量开辟一片空间，并使用引用名c作为别名，且不能再对引用名引用。

1：引用本来就相当于一个常指针：* const t

2：再加一个const表示指针指向的内存空间也不可修改

3：作用：1.让变量所指向的内存空间只读 2.指向常量

4：给const引用初始化有两种方法

引用对占不占存储空间：

引用不会为其所指向的变量从新分配空间，并不代表引用本身不占空间。引用其实和指针一样占用四个字节（和int一样）

引用于指针的区别：

相同点：底层的实现方式相同，都是按照指针的方式实现。

不同点：

引用在定义时必须初始化，指针没有要求。
一旦一个引用被初始化指向一个对象，就不能再指向其他对象，而指针可以在任何时候指向任何一个同类型对象。
没有NULL引用，但有NULL指针。
在sizeof中含义不同，指针始终为地址空间所在字节个数（任何类型都是4字节），引用的sizeof为所指向对象内存分配空间的大小（单位为字节）。
引用自加改变变量内容，指针自加改变了指针的指向。
有多级指针，没有多级引用。
指针手动寻址，引用通过编译器实现寻址。
引用比指针使用起来更安全。