【C++】const修饰一级指针、二级指针、引用、形参返回值的用法

引用（&）：引用就是一个别名

1. 引用一定要初始化      // int &b;    error                                                                                                                              
2. 引用引用的变量一定要能取地址  // 是内存单元的别名        
3. 引用不可改变  // b如果是a的别名，那么b不可以再引用c
4. 引用只能访问引用变量所引用的内存块的值  // 系统自带解引用   

   底层以指针的方式来支持引用

void Swap(int &a,int &b)  //a修改的是c的内存单元
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int c = 10;
	int d = 20;
	Swap(c,d);
	cout << "c:" << c << endl; 
	cout << "d:" << d << endl;

	return 0;
}

1 . const修饰常量：声明的同时必须进行初始化。一旦声明，这个值将不能被改变。

int main()
{
	const int i = 2;
	i = 5; //const 修饰i，i从变量转化为常量，值不可修改
	const int j = 3; //√  
	const int k; //const修饰常量一定要初始化
	return 0;
}

2 . const与一级指针的结合

  可以利用C语言权限扩大缩小来判断、但也仅限于一级指针 

int main()
{
	int  a = 10;
	int* p = &a; // p中存放a的地址
	int* q = p;  // q指向a

	const int a = 10;
	const int* p = &a; //有修改常量内存块的风险要加 const
	int* q = p; // const int* q = p;  √
	/* 
	C语言通过权限扩大缩小来判断是否正确（只适合判断const与一级指针的结合）：
	     第三句中：int * <== const int *  权限扩大，错误
	C++中通过杜绝间接访问来减小风险：
	      a是直接访问
	      *p 和 *q 是间接访问，为了杜绝风险，前面都加 const
	*/

	int a = 10;
	const int* p = &a;
	int* q = p; // const int* q = p;  √
	/*
	C语言判断：第三句 int * <== const int *  权限扩大，错误
	C++判断：a是直接访问
	         *p 和 *q 是间接访问，为了杜绝风险，前面都加 const
	*/

	int a = 10;
	int* const p = &a; //const修饰p
	int*q = p; //int * <==> int *  同级
	/*
	    √
	*/

	int  a = 10;
	int* p = &a;
	const int* q = p; // 从const修饰的代码往下看
	/*
	    √
	*/

	int a = 10;
	int* p = &a;
	int* const q = p; //const修饰q，直接访问就是q，无间接访问
	/*
	     √
	*/

	return 0;
}

2 . const与二级指针的结合 

  在杜绝间接访问来减少风险时，二级指针的间接访问不一定只有一个，但是我们只需要杜绝一个即可运行。

int main()
{
	int a = 10;
	int* p = &a;
	int**q = &p; //q直接访问a

	const int a = 10;
	const int* p = &a; //const修饰*p，直接访问a
	int**q = &p; // const int**q = &p; √
	/*
	C++：直接访问a 
	     间接访问*p，**q，为了杜绝风险，const进行修饰
	*/

	int a = 10;
	const int* p = &a; //直接访问a
	int**q = &p; //const int**q = &p;
	/*
	C++：直接访问a 
	     间接访问*p，**q，为了杜绝风险，const进行修饰
	*/

	int a = 10;
	int* const p = &a; //const修饰p
	int**q = &p; //int*const*q = &p  √
	/*
	C++：直接访问p
	     间接访问*q可以得到p，为了杜绝风险，const进行修饰
	*/

	int a = 10;
	int* p = &a; //const int* p = &a;  √
	const int**q = &p; //const int*const*q = &p;
	/*
	  **q中有两个间接访问：**q和*q
	  ！  int** 不可以转化为 const int**
	*/

	int a = 10;
	int* p = &a;
	int*const*q = &p; //const修饰*q
	/*
	 直接访问p
	 间接访问*q，*q有const修饰
	    √
	*/

	int a = 10;
	int* p = &a;
	int**const q = &p; //const修饰q，直接访问q、无间接访问
	/*
	     √
	*/

	return 0;
}

3 . const与引用的结合

引用引用的变量不能取地址  ==>  常引用可以处理

数值放到临时量（内存），常引用引用临时量的内存单元

int& a = 10 //error! 
const int& a = 10; //√

//当引用引用的变量不能取地址使，常引用可以处理

4 . const与形参的结合

1. 防止实参被修改（指针或引用）
2. 接受临时量  //内置类型临时量为常量  

引用做形参  普通变量做形参 

1. 引用修改实参的值 
2. 引用不能引用立即数，部分实参无法调用

5 . const与返回值的结合

不能返回局部变量的地址或引用！