const用法详解，&（引用）的本质

const 用法详解与引用

一.const修饰常量、指针

#include <iostream>
#include <stdio.h>
using namespace std;

//1.const修饰常量
void test1() {
	const int i = 10;
	int const j = 5;//这与上一种写法意义完全相同，不过一般使用第一种写法
	//const int k;//ERROR!const 修饰的常量必须进行初始化
	//i = 3;//ERROR!const修饰的常量不能对值进行修改
	//j = 2;//ERROR!const修饰的常量不能对值进行修改
}

//2.const修饰指针 常量指针:指针是常量
void test2() {
	const int *i;
	int const *j;//这两种意义相同，都是可以改变指针的地址，但不能改变地址的值
	//也就是说不能直接改变*i, *j, 但是可以改变i, j 的指向

	//*i = 5, *j = 10;//ERROR!不能改变地址内的值
	
	int a = 5, b = 10;
	i = &a, j = &b;
	a = 1, b = 2;//注意，虽然不能直接改变*i ,*j, 但是可以通过直接改变地址内的值来间接改变*i, *j
	cout << *i << "," << *j << endl;
}

//3.const修饰指针  指针常量:指针指向的是常量
void test3() {
	int a = 1;
	int * const i = &a;//i必须进行初始化，因为指向地址不能改变
	*i = 2;
	cout << "a = " << a << ", i = " << *i << endl;

	int b = 3;
	//i = &b;//ERROR!不能改变i 的指向
}

//4. const修饰指针
void test4() {
	int a = 4;
	const int * const i = &a;//这样的话就都不能改变了
}



int main()
{
	test3();
	return 0;
}

二.const修饰类与类成员

#include <iostream>
#include <stdio.h>
using namespace std;

class A {
public:
	A(int a):_a(a){
		//如果构造函数中没有对_a初始化，编译器则会报错
		_b = 10;
	}

	void getValconst()const {
		_a = 2;//ERROR! const修饰的函数中不能对成员变量进行修改，只能进行访问
		_b = 2;//ERROR! const修饰的函数中不能对成员变量进行修改，只能进行访问

		cout << "_a = " << _a << ", _b = " << _b << endl;//const修饰的成员函数，不管成员变量是否为const修饰，都可以访问，但是不能修改
	}

	void getVal(){
		cout << "_a = " << _a << ", _b = " << _b << endl;//普通函数也可以访问
	}


private:
	const int _a;//注意，const修饰的成员变量必须在构造函数中进行初始化
	int _b;
};


int main()
{

	return 0;
}

总结：
1.const修饰的成员变量必须一开始就进行初始化，且初始化后不能被修改。
2.const修饰的函数不能修改任何成员变量。

三.const 修饰引用

#include <iostream>
#include <stdio.h>
using namespace std;


//1.一般引用的用法
void test1() {
	int a = 1;
	int &i = a;
	i = 2;
	cout << "i = " << i << ", a = " << a << endl;//引用成功！

	//int &j;//ERROR!引用必须绑定变量
	//int &j = 1;//ERROR!引用必须绑定一个变量
	double d = 2.3;
	//int &j = d;//ERROR!类型不一致
}

/*
2.引用的本质：const* 
实质上引用& == *const  , 也就是说 int &i = a; 是  int *const i = &a;的简化写法
引用隐藏了指针，我们可以将之看作成绑定变量的另外一个别名来使用，但是其本质还是指针 *const。
理解了这些，便可以理解为什么绑定必须初始化，类型必须相同，不能绑定常数等等了。
*/
void test2() {
	int a = 1;
	int &i = a;
	i = 2;
	cout << "i = " << i << ", a = " << a << endl;//引用成功！
	
	int b = 1;
	int * const j = &b;
	*j = 2;
	cout << "*j = " << *j << ", b = " << b << endl;//引用成功！


}


//3.const 修饰引用
void test3() {
	const int &i = 1;
	/*
	编译器内部处理：
	int temp = 1;
	const int &i = temp;
	*/
	
	double d = 2.3;
	const int &j = d;
	d = 3;
	cout << "j = " << j << endl;
	/*
	编译器内部处理：
	int temp = d;
	const int &i = temp;
	这也是为什么d改变之后，j却没有改变的原因
	*/
	

	int a = 1;
	const int& k = a;
	//由于操作合法，所以编译器就按正常绑定了
	a = 2;
	cout << "a = " << a << ", k = " << k << endl;

}



int main()
{
	
	return 0;
}