指针常量，常量指针，常量引用，引用常量，指针数组，数组指针，引用数组，数组引用的梳理

C++中的声明

*1.指针常量: int * const p
2.常量指针: int const p (const int p)
3.引用常量：int& cosnt rp (合法，但是多余)
4.常量引用：int const &rp（const int& p）
5.指针数组：int*pa[]
6.数组指针：int (pa)[]
7.引用(的)数组：int& ra[] ！！！！ (不合法)！！！！！！！
8.数组(的)引用：int (&ra) []

指针常量：int * const p

正如声明的顺序 * 在const前，所以先读*在读cosnt 即指针常量。
p为一个指针，const直接修饰的是p，所以p这个指针不能变（也就是p的指向不能变），但是p指向的变量的值可以变。

int a = 10；int b = 20；
int* const p1 = &a；
*p1 = 11； //合法
p1 = &b； //不合法

常量指针：int const p (const int p)

正如声明的顺序 const在 * 前，所以先读 const 在读 * 即常量指针
p是一个指针，const直接修饰的是p，而p是p所指向的变量的值，所以这里不能变的是p所指向的变量的值 ，也就是说 不能通过*p修改值。

int a = 10；int b = 20；
int const * p2 = &a； // const int* p2 = &a;
*p2 = 11； //不合法
p2 = &b； //合法

常量引用：int const &rp（const int& p）
正如声明的顺序 const在 &前，所以先读 const 在读 & 即常量引用
rp是一个引用，const直接修饰的是&rp，而&rp代表的是声明一个引用，所以这里不能变的是rp所引用的变量的值 ，也就是说 不能通过rp修改值。

int a = 10；int b = 20；
int const &rp = a;
rp = 11；//不合法
rp = b；//不合法

但是可以通过const_cast<int&>(rp)去掉&rp的const属性，使之暂时可以赋值。注意之所以所暂时，是因为只有这条语句成立，如果以后想继续赋别的值
那么需要再用一次const_cast<int&>(rp)
如：
const_cast<int&>(rp) = 11;
const_cast<int&>(rp) = b;

另外：对于常量 const int c = 30； 对齐进行引用必须用 int const &rp = c;
但是const_cast<int&>(rp) = 11;并不会改变c的值（因为c会进入符号表）

引用常量：int& cosnt rp (合法，但是多余)

正如声明的顺序 & 在 const 前，所以先读 &在读 const 即引用常量
rp是一个引用，const直接修饰的是rp，所以这里不能变的是rp的引用对象，也就是说 在后续中，rp不能成为别的变量的引用。
这显然是废话，因为C++中的引用必须在声明时同时定义，就是说创建引用时必须指定其引用的对象，此后不能修改引用所引用的对象。

int a = 10；int b = 20；
int& const rp = a;
rp = 11; //合法
rp = b； //合法，此时a = 20；
//但是这是多余的

指针（的）数组：int*pa[]

[] 的优先级比 * 高，所以pa先结合 [] 。即，pa是一个数组，这个数组中存放的内容是int *（int 型的指针）。

int a = 1; int b = 2; int c = 3;
int* pa[] = { &a,&b,&c };
cout << **pa << endl;   //输出  1
cout << **(pa + 1) << endl; // 输出 2
cout << **(pa + 2) << endl; // 输出3

数组（的）指针：int (*pa)[]

（）优先级最高，pa先和 * 结合 ，得pa是一个指针，这个指针指向一个元素为int的数组。

int arr1[3][2] = { {1,2 }, { 3, 4}, {5,6} };
int(*pa)[2] = arr1;   
cout << **pa << endl;  		//输出 1
cout << **(pa + 1) << endl; 	//输出 3
cout << *(*pa+1) << endl; 	//输出 2
cout << **(pa + 2) << endl;	//输出 5
cout << *(*(pa + 2) + 1) << endl; //输出6

引用(的)数组：int& ra[] ！！！！ (不合法)！！！！！！！

[]的优先级会比&优先级高，所以ra先结合[]，也就是说ra首先是一个数组，其次，这个数组中的内容是int &(存放的是一些列变量的引用)。
但这个明显就是不合法的，因为引用只是取了一个别名，本身并不占用内存，而数组是会占用内存的，所以引用的数组是错误的。

int array[2]={1， 2};
int& ra[] = array //可以理解为(int&) ra[],即ra为数组，数组中的元素为引用
//这是不合法的

数组(的)引用：int (&ra) []

（）优先级最高，所以先解决在（）中的，ra先于&结合，ra是一个引用，ra引用的是一个数组，这个数组存放的数据类型是int。

int array[2]={1, 2};
int (&ra)[2]= array; //ra为引用，引用对象为array
ra[0]=3;
cout<<array[0]<<endl; //输出为3