	int a = 10, b = 20;
	int* p = &a;
	p = &b;		// 改變指向的權(quán)限  ?
	*p = 30;	// 修改內(nèi)存的權(quán)限  ?
	const int* cp = &a;	// 限制修改權(quán)限
	//*cp = 100;		// error：表達(dá)式必須是可修改的左值	修改 ?
	cp = &b;			// ok.								指向 ?
	int* const pa = &a;	// 限制指向權(quán)限
	*pa = 100;			// ok.								修改 ?
	//pa = &b;			// error：表達(dá)式必須是可修改的左值  指向 ?

指針的賦值一般遵守權(quán)限縮小式的賦值。例如，我有一本書(shū)，我有使用權(quán)限（我可以看，可以做筆記），借給你后你只有閱讀權(quán)限（只能看，不能做筆記）。當(dāng)然，如果我們關(guān)系好，我可以賦予你使用權(quán)（你擁有讀寫(xiě)的權(quán)利）。同樣的，指針的賦值也是如此。

	int a = 10;
	int* p = &a;	// int*  <==  int *
	int* q = p;				// int*  <== int*
	const int* cp = p;		// const int*  <==  int*	權(quán)限縮小，?
	int* const pa = p;		// int*	 <== int*			注意：int* const pa;是“int*”類型
	//int* p1 = cp;	// error：int*  <== const int *     權(quán)限放大，?
	int* p2 = pa;	// ok.    int*  <== int*

我們可以得出一級(jí)指針賦值的公式

int *       <==  int *		// int* 包含 int* 和 int* const類型
int const * <==  int *		// int const * <=等同=> const int *
// 以上公式反過(guò)來(lái)賦值就是錯(cuò)誤的..

練習(xí)一：一級(jí)指針指向練習(xí)題

題目一：下列表達(dá)式語(yǔ)句賦值錯(cuò)誤的是？

	int a = 10;
	const int* p = &a;
	int* q = p;		
	int a = 10;
	int* const p = &a;
	int* q = p;
	int a = 10;
	int* const p = &a;
	int* const q = p;
	int a = 10;
	int* const p = &a;
	const int* q = p;

答案：(鼠標(biāo)選中查看）

??錯(cuò)誤：A，正確：B、C、D??

解析：

	int a = 10;
	const int* p1 = &a;
	int* q1 = p1;				// error：無(wú)法從const int * 轉(zhuǎn)為 int *
	/* 分析：
		int* <= cosnt int*
	*/
	int* const p2 = &a;
	int* q2 = p2;
	/* 分析：
		int* <= int*
	*/
	int* const p3 = &a;
	int* const q3 = p3;
	/* 分析：
		int* <= int*
	*/
	int* const p4 = &a;
	const int* q4 = p4;
	/* 分析：
		cosnt int* <= int*
	*/

練習(xí)二：二級(jí)指針指向練習(xí)題

題目二：下列表達(dá)式語(yǔ)句錯(cuò)誤的有。

// 選項(xiàng)A
int a = 10;
int* p1 = &a;
const int** q1 = &p1;	
// 選項(xiàng)B
int a = 10;
int* p2 = &a;
int* const* q2 = &p2;
// 選項(xiàng)C
int a = 10;
int* p3 = &a;
int** const q3 = &p3;
// 選項(xiàng)D
int a = 10;
int* const p4 = &a;
int** q4 = &p4;	
// 選項(xiàng)E
int a = 10;
const int* p5 = &a;
int* const* q5 = &p5;

答案：(鼠標(biāo)選中查看）

??錯(cuò)誤：A、D、E，正確：B、C??

A選項(xiàng)；

錯(cuò)誤; 注：如果const修飾的是二級(jí)指針，我們需要對(duì)二級(jí)指針的逐層解引用進(jìn)行分析。

	int* p1 = &a;
	const int** q1 = &p1;	//error  無(wú)法從“int * *”轉(zhuǎn)換為“const int** ”

int* p1 = &a; p1的類型為int* 取地址為 int **const int** q1 = &p1; q1的類型為 const int **則指針賦值過(guò)程為 const int ** <= int* *

分析：

const作用于（**q1），修飾二級(jí)指針。表示不可通過(guò)q1對(duì) a 的值進(jìn)行修改。
*q1 解引用一次后，為一級(jí)指針，即 p1 。但是 p1 存在對(duì) a 修改的風(fēng)險(xiǎn)，因此無(wú)法直接賦值。

修改方案：

方案一：直接限定一級(jí)指針p1。保證p1不會(huì)修改a的值，即const int * p1= &a; const int** q1 = &p1;
方案二：間接限定q1，使其指向時(shí)縮小權(quán)限，對(duì)解引用后的（*q1）修改的權(quán)限做出限制，如：const int * const * q1;

	// 方案一
	const int* p12 = &a;
	const int** q12 = &p12;

	// 方案二
	int* p11 = &a;
	const int* const* q11 = &p1;

B選項(xiàng)；

正確; 注：如果const修飾的是一級(jí)指針，我們可以拋開(kāi)二級(jí)指針的表象，但看一級(jí)指針的賦值操作是否正確。如本例。

	int* p2 = &a;			
	int* const* q2 = &p2;
	/* 分析：
		int* const*  <==  int* *
		const修飾 *q2，即cosnt修飾一級(jí)指針
		cosnt*  <== *				// 去掉前面的 int* <= int*
		int const *  <== int *		// 添加一個(gè)任意類型，如int
			如??所示，這是一個(gè)權(quán)限縮小的一級(jí)指針賦值，?
	*/

C選項(xiàng)；

正確; 注：如果兩邊類型相同，則無(wú)需進(jìn)行判斷。如本例。

	int* p3 = &a;
	int** const q3 = &p3;
	cout << typeid(q3).name() << endl;	//輸出 q3 類型   int * *
	/* 分析：
		int**const  <== int* *  即  int**  <== int* *
		兩邊類型相同，無(wú)需進(jìn)行特殊判斷，?
	*/

ps：如果const修飾的參數(shù)右邊無(wú)“*”號(hào)，則該cosnt不作用于類型。如：

	int n = 10;
	// 使用typeid(valtypr).name() 輸出變量類型
	int const* p1 = &n;		// int const *
	int* const p2 = &n;		// int *			// 忽略const
	int* p = &n;
	int** q = &p;
	//int const** q1 = &p;		
	int const* const* q1 = &p;	   // int const* const*
	int* const* q2 = &p;		   // int* const*
	int** const q3 = &p;		   // int**		// 忽略cosnt

D選項(xiàng)；

錯(cuò)誤; 同B選項(xiàng)相同，對(duì)于const修飾的一級(jí)指針進(jìn)行判即可。

	int* const p4 = &a;
	int** q4 = &p4;			//error  "int *const *"類型的值不能用于初始化"int **類型的實(shí)體

int* const p4 = &a; 類型為 int*，因?yàn)閏onst的存在，取地址后類型為 int * const *int** q4 = &p4; 類型為 int**則指針賦值過(guò)程為 int** <== int* const*

分析：

const作用于（p4）,修飾一級(jí)指針。則我們忽略沒(méi)有const修飾的部分。即* <== const* ，//忽略 int 部分，該部分賦值時(shí)權(quán)限沒(méi)有發(fā)生變化。int* <== int const * ，給指針確定一個(gè)類型，如“int” 類型
如??，我們可以看到，該表達(dá)式語(yǔ)句想從int const* 類型處，獲得一個(gè) int* 類型的賦值，也就是說(shuō)這是權(quán)限放大式的賦值。錯(cuò)誤原因：該賦值會(huì)使得 int* 類型指針對(duì)常量（int const* 所指向的值）產(chǎn)生修改的風(fēng)險(xiǎn)。

修改方案：

把int* <== int const *型賦值改成 int const* <== int const *類型賦值即,int*const* q4 = &p4;

E選項(xiàng)；

錯(cuò)誤; 注：如果賦值兩邊都有const時(shí)，各論各的分析，如下。

	const int* p5 = &a;
	int* const* q5 = &p5;	//error  無(wú)法從"const int **"轉(zhuǎn)換為"int *const *"

分析：

省略分析過(guò)程等賦值類型為 int* const* <== const int* *
分情況分析：
- 提取指針左邊部分：int* <== const int* ，錯(cuò)誤 ?
- 提取指針右邊部分：cosnt * <== * 即 int const * <== int *，正確 ?
綜上，錯(cuò)誤 ?。

修改方案：

1.修改指針左邊類型：int* <== const int* ⇒ int* <= int*

2.修改指針左邊類型：int* <== const int* ⇒ const int* <= const int*

	//1 int* <= int*
	int* p51 = &a;					// const int* p5  ?   int* p51
	int* const* q51 = &p51;
	//2 const int*  <= const int*
	const int* p52 = &a;
	const int* const* q52 = &p52;	// int* const* q5 ?   const int* const* q52

方法總結(jié)：

對(duì)于二級(jí)指針的賦值操作判斷，看const位置、主要有以下兩種情況：

如果 const修飾的是二級(jí)指針 如：
- int const ** ，如選項(xiàng)A。我們需要考慮其解引用情況。cosnt修飾二級(jí)指針?biāo)赶虻闹禐槌Ａ?，但是由于一次解引用后的指針?huì)存在修改常量的風(fēng)險(xiǎn)，因此我們需要限制該指針與常量之間進(jìn)行過(guò)度的一級(jí)指針
- 針對(duì)此類二級(jí)指針，我們只需記住合法的賦值為等式兩邊需同時(shí)有const ，const int* cosnt* <== int**或 左邊等式有兩個(gè)cosnt ，const int* cosnt* <== int** 。
如果 const修飾的是一級(jí)指針或其他如：