C++中的引用（重要知识点）

前言：

引用即别名
对变量取另外的名称，相当于是取了一个错号。引用变量与其所引用的变量的地址其实是同一个；
C++用引用来取代指针

声明引用变量：
数据类型& 变量名 = 变量;
数据类型 和 变量 的类型必须完全一致；

一、引用的知识点：

1.引用必须初始化 引用一经定义必须初始化
int& z; //错误的

#include <iostream>
using namespace std;

int func(int& b){
	b = 119;	
}

void exchange(int& a,int& b){
	int t = a;
	a = b;
	b = t;
}

int main(){
	int a = 10;
	int& b = a;//声明引用变量b  引用了a
	cout << b << endl;
	
	b = 111119;
	cout << a << endl;
	
	cout << &a << endl;
	cout << &b << endl;
	func(a);
	cout << a << endl;
	int x = 10;
	int y = 20;
	exchange(x,y);
	cout << x << "," << y << endl;
	return 0;	
}

2.引用一经初始化 (引用不能再引用其它变量) 不能改变引用对象

#include <iostream>
using namespace std;

int main(){
	int x = 10;
	int&y = x;
	double d = 3.14;
	double& e = d;

	//int& z = d;
	int& z = x;
	int m = 13;
	z = m;//不是让引用z去引用m变量  而是把m的值赋值给z
	cout << z << endl;
	cout << x << endl;

	z = 100;
	cout << m << endl;//13  z引用x，而非m,所以修改z并不影响m
	cout << x << endl;
	
	return 0;	
}

3.引用不能为空 没有空引用 但指针可以指向NULL

#include <iostream>
using namespace std;

int main(){
	int x = 10;
	//int* p,x;
	//int* p1,*y;
	int& rx = x, ry = x;//rx引用x  ry是一个int类型变量 用x初始化
	int& rm = x, &rn = x;//rm 和 rn都是引用变量 引用x
	x = 100;
	cout << rx << endl;
	cout << rm << endl;
	cout << rn << endl;
	cout << ry << endl;

	//int rx;
	return 0;	
}

4.常引用
const int& r = 100; //常量引用 常引用 即引用常量的引用
不能通过该引用变量修改所引用对象的值

例1：

#include <iostream>
using namespace std;


int main(){
	const int x = 10;//x不会再变  宏 所有使用x的地方 直接用10替换	
	//int z = const_cast<int>(x);

	const int *p = &x;
	//int *px = &x; //在C++中 const int *类型不能隐式转换成 int*
	int *px = const_cast<int*>(&x);//去除指针的常属性
	*px = 1000;
	cout << x << endl;//10
	cout << *px << endl;//1000
	cout << &x << endl;
	cout << px << endl;
	cout << *p << endl;	
	
	int y = x;
	cout << y << endl;

	cout << *(&x) << endl;//  x  10
	//int * const p;	
	const int *p1 = &x;
	cout << *p1 << endl; //1000
	return 0;	
}

例2：

#include <iostream>
using namespace std;

void fun(const int& r){
	//r = 100;	
}

int main(){
	int x = 10;
	fun(x);
	fun(1);
	const int &r = 100;//引用常量   常引用   即引用常量的引用
	//int& rx = 10;
	int &rx = const_cast<int&>(r);
	cout << rx << endl;
	//r = 119;
	rx = 119;
	cout << r << endl;
	cout << rx << endl;
	return 0;	
}

例3：

#include <iostream>
using namespace std;

int main(){
	const int x = 10;//x相当于宏 x用10替换
	//const int& rx = x;
	//rx = 100;
	int& rx = const_cast<int&>(x);
	rx = 1000;
	cout << x << endl;//不会改变
	cout << rx << endl;
	const int *p = &x;
	cout << *p << endl;

	const int& rz = 10;
	int& ry = const_cast<int&>(rz);
	ry = 1000;
	cout << rz << endl;
	cout << ry << endl;

	return 0;	
}

5.引用的作用：
（1）作为函数的参数
在函数中可以修改实参的值
如果在函数的参数中用const来修饰引用参数，防止在函数中修改该引用变量所引用对象的值
（2）作为函数的返回值
如果函数返回引用，则该函数的返回值可以作为左值
注意：不要返回局部变量的引用
能够返回全局变量、静态变量、动态内存、引用形参的 引用
（3）提高参数传递的效率
普通的传递 值 复制传递
const int& fun(const int& r){
}

#include <iostream>
using namespace std;

int& max(int& m,int& n){
	return m>n?m:n;	
}

int main(){
	int x = 10;
	int y = 100;
	int& z = max(x,y);
	cout << z << endl;
	z = 1000000;
	cout << y << endl;
	//让函数的返回值作为左值
	max(x,y) = 1;
	cout << y << endl;
	return 0;	
}

6.引用的本质其实就是指针，引用的底层实现是指针

二、引用与指针的区别？

1.指针是实体变量 引用不是实体变量
任何一种类型 定义一个变量 sizeof(变量) 不会变

#include <iostream>
using namespace std;

void fun(int& a){
	
}

int main(){
	char a = 'a';
	char& ra = a;
	char *pa = &a;
	cout << sizeof(pa) << endl;
	cout << sizeof(ra) << endl;

	short s = 111;
	short& rs = s;
	short *ps = &s;
	cout << sizeof(ps) << endl;
	cout << sizeof(rs) << endl;

	int i = 129;
	int& ri = i;
	int *pi = &i;
	cout << sizeof(pi) << endl;
	cout << sizeof(ri) << endl;

	double d = 3.14;
	double& rd = d;
	double *pd = &d;
	cout << sizeof(pd) << endl;
	cout << sizeof(rd) << endl;
	
	
	return 0;	
}

2.指针可以不初始化 引用必须初始化
3.指针可以改变指向 引用不能改变"引向" 一经引用一个对象之后 不能再引用其它对象
4.指针可以指向为空(NULL) 引用不能引用为空
函数形参为引用时 是在调用时 初始化 而并不是引用为空
5.可以声明指针的引用 但不能声明引用的指针

	int a = 10;
	int *pa = &a;
	int* &rp = pa;   //rp 引用 pa
	
	int& rx = a;
	int& *px = ℞  //错误的  没有 int& 类型的指针
	int *px = ℞   //正确的  引用变量的地址类型 即为 引用变量所引用对象的类型

代码：

#include <iostream>
using namespace std;


int main(){
	int a = 10;
	int *pa = &a;

	int* & rp = pa;//rp是一个引用  rp引用一个指针  rp == pa
	//& 表示是引用变量   int*  是表示引用变量的类型
	cout << rp << endl;
	cout << *rp << endl;	
	
	int& x = a;
	//int& *px = &x;//错误的
	int *px = &x;

	//int&& rx = x;//错误的
	int& rx = x;

	return 0;	
}

6.可以声明指针的指针 但不能声明引用的引用

	int a = 10;
	int *pa = &a;
	int **ppa = &pa;
	
	int& ra = a;
	int&& rra = ra;//错误的
	int& rra = ra;

7.可以声明数组的引用 但不能声明引用的数组

	int arr[5] = {1,2,3,4,5};
	int (&rArr)[5] = arr;    //rArr是一个引用变量 引用一个数组
	int a,b,c,d,e;
	int& arr[5] = {a,b,c,d,e};//引用类型的数组不行

代码：

#include <iostream>
using namespace std;

int main(){
	int arr[5] = {1,2,3,4,5};
	int (&rb)[5] = arr;
	rb[0] = 100;
	rb[3] = 455;
	for(int i=0;i<5;i++){
		cout << rb[i] << " ";	
	}
	cout << endl;
	int a=1,b=2,c=3,d=4,e=5;
	//int& brr[5] = {a,b,c,d,e};//不能声明引用的数组
	return 0;	
}