这里3节课课程名称希望能够进一步细化，会更好理解。大致有以下内容，相互有交织，内容非常大而且细，非常容易混淆：

- 指针声明中const的三种使用情况：const pointer、pointer to const、const pointer to const。注意const对指针本身或指针所指内容的保护性。

- 顶层const：普通常量与const pointer

- 底层const：指向常量的指针、常量的引用

//以下又开始涉及函数传参时的类型匹配的知识

- 传参不涉及指针时，const int类型实参可以传参给int形参，反之亦然。

- 传参且涉及指针时，“const int类型的指针作为实参”不能传参给“int类型的指针作为形参”；反之，“int类型的指针作为实参”可以传参给“const int类型的指针作为实参”。

//以下又包括前面课程函数传参方式的值传递、指针传递的理解，是关于const给予不同部分保护的知识

- 传参时，普通指针、const pointer、pointer to const、const pointer to const以上四种都可以作为形参出现在函数的参数列表中，实现对“实参指针本身”“作为形参的指针本身”或“作为形参的指针与实参指针共同所指的对象”的针对性保护（禁止函数修改），如下（这里整理成表格会更清晰）：

1. func(int p);//值传递-普通变量：函数内保护实参，不保护形参。
2. func(const int p);//值传递-常量：函数内保护实参，保护形参副本。
3. func(int* a);//指针传递-普通指针：函数内保护实参（指针本身），不保护形参指针，不保护指针所指对象
4. func(const int* p);  //等价写法：func(int const* p);指针传递-指向常量的指针：函数内保护实参，不保护形参指针，保护指针所指对象
5. func(int* const p);//指针传递-指针常量：函数内保护实参，保护形参指针，不保护指针所指对象
6. func(const int* const p);//指针传递-指向常量的常量指针：全都保护

const形参和实参

总结：

1.int cube(int i); 实参可以为int类型，也可以为const int类型。在函数体中可以修改i的值，函数不会修改实参的值。

2.int cube(const int i); 实参可以为int类型，也可以为const int类型。在函数体中不可以修改i的值，函数不会修改实参的值。

总结：

3.int pCube(int* pi); 实参为int*类型的指针，不能为const int*类型。可以通过修改*pi的值修改实参指向的对象的值，修改pi对实参没有影响。

4.int pCube(const int *pi); 实参可以为const int*类型，也可以为int*类型。不可以通过修改*pi的值修改实参指向的对象的值，修改pi对实参没有影响。

5.int pCube(int * const pi); 实参为int*类型，不能为const int*类型。可以通过修改*pi的值修改实参指向的对象的值，不可以给pi赋值。

总结：

6.void reset(int &r); 实参为int类型，不可以为const int类型。可以通过修改r的值，从而修改实参的值。

7.void print(const int &r); 实参可以为int类型，也可以为const int类型，不可以修改r的值

#include <iostream>

using namespace std;

int cube1(int i);
int cube2(const int i);

int pCube1(int *pi);
int pCube2(const int *pi);
int pCube3(int* const pi);

int rCube1(int &r);
int rCube2(const int &r);

int main()
{
	//num1 为 int 类型的变量，可以修改它的值
	//num2 为 int 类型的常量，不可以修改它的值
	int num1 = 10;
	const int num2 = 10;
	num1 = 20;
	//num2 = 10;//出错

	//普通指针，可以修改p1的值，也可以修改*p1来修改num1的值。
	//所以只能用int类型的数据来初始化，不能用const int类型，不能修改常量的值。
	int *p1 = &num1;
	//int *p2 = &num2;//出错
	
	//底层const，可以修改指针（p3，p4），但是不可以修改*p3，*p4，去修改num1，num2的值。
	//可以使用int类型或const int 类型的数据来初始化
	const int *p3 = &num1;
	const int *p4 = &num2;

	//顶层const，不可以修改指针（p5，p6），但是可以通过*p5去修改num1的值。
	//所以只能使用int类型的数据来初始化，不能const int类型
	int * const p5 = &num1;
	//int * const p6 = &num2; //错误

	//int类型的引用，可以通过r1去修改num1的值，所以只能使用int类型去初始化，不能使用const int类型
	int &r1 = num1;
	//int &r2 = num2; //出错

	//const int 类型的引用，不能修改r3,r4的值
	//可以使用int类型的数据来初始化，也可以使用const int类型
	const int &r3 = num1;
	const int &r4 = num2;

	//实参为int类型或const int类型
	cout << cube1(num1)<<" "<< cube1(num2) << endl;
	cout << cube2(num1) << " " << cube2(num2) << endl;

	//实参只能为int类型
	cout << pCube1(&num1) << endl;
	//cout << pCube1(&num2) << endl; //出错

	//所以实参可以是int类型，const int类型
	cout << pCube2(&num1) << " " << pCube2(&num2) << endl;
	
	//实参类型只能是int类型
	cout << pCube3(&num1) << endl;
	//cout << pCube3(&num2) << endl; //出错

	//实参只能是int类型
	cout << rCube1(num1) << endl;
	//cout << rCube1(num2) << endl; //出错

	//实参类型可以是int类型，也可以是const int类型
	cout << rCube2(num1) << " " << rCube2(num2) << endl;

	return 0;
}

//可以修改形参i
int cube1(int i)
{
	//i = 0;
	return i * i * i;
}

//不可以修改形参i
int cube2(const int i)
{
	//i = 0; //出错
	return i * i * i;
}

int pCube1(int *pi)
{
	//*pi = 0;
	return *pi * (*pi) * (*pi);
}

//可以修改pi，但是不可以修改*pi，所以实参可以是int类型，const int类型
int pCube2(const int *pi)
{
	//*pi=0; //出错
	return *pi * (*pi) * (*pi);
}

//不可以修改pi，但是可以修改*pi，所以实参类型只能是int类型
int pCube3(int* const pi)
{
	//*pi=0;
	return *pi * (*pi) * (*pi);
}

//可以修改r，实参只能是int类型
int rCube1(int &r)
{
	//r = r * r * r;
	return r * r * r;
}

//不可以修改r，实参类型可以是int类型，也可以是const int类型
int rCube2(const int &r)
{
	//r = r * r * r; //出错
	return r * r * r;
}