在 玩透指標系列（一）中我們已經知道了指標的基礎知識：
1 指標就是個變數，用來存放地址，地址唯一標識一塊記憶體空間，
2. 指標的大小是固定的4/8個位元組（32位平臺/64位平臺），
3. 指標是有型別，指標的型別決定了指標的±整數的步長，指標解參考操作的時候的權限，
4. 指標的運算，

接下來在本篇博客中將繼續探究指標的進階知識，

1.字符指標

在指標的型別中我們知道有一種指標型別為字符指標 char*
一般用法：

int main()
{
  char ch = 'w';//此時的'w'為常量字符
  char *pc = &ch;
  *pc = 'w';
  return 0;
}

還有一種使用方式：

int main()
{
char* pstr = "hello girl.";//此時"hello bit."為常量字串
printf("%s\n",pstr);
return 0;
}

說明：上述的 “hello girl.” 為常量字串，不能改變，
那么“ char* pstr = “hello girl.”; ” 這句代碼的意思是把一個字串放到 pstr 指標變數里了嗎？
其實不是，上述代碼的本質是把字串 “hello girl.” 的首字符的地址放到了 pstr 中，如圖：

即把首字符 ‘ h ’ 的地址存放在指標變數 pstr 中，
我們要知道，列印一個字串只需要提供字串的首元素地址即可，既然字符指標 pstr 中存放的是字串的首元素地址，那么我們只要提供pstr（字串首地址）并以字串的形式列印，便可以列印字串 "hello girt.”（與列印字串陣列一樣，提供陣列名（實質上也為首元素的地址）然后以字串的形式列印出字串） ，
如：

為了更好的理解字符指標和常量字串，有如下代碼：

#include <stdio.h>
int main()
{
	char str1[] = "hello girl.";
	char str2[] = "hello girl.";
	char *str3 = "hello girl.";
	char *str4 = "hello girl.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");

	return 0;
}

原因：
這里str3和str4指向的是一個同一個常量字串，C/C++會把常量字串存盤到單獨的一個記憶體區域，當幾個指標，指向同一個字串的時候，他們實際會指向同一塊記憶體，但是用相同的常量字串去初始化不同的陣列的時候就會開辟出不同的記憶體塊，所以str1和str2不同，str3和str4相同，
看圖理解：

2.指標陣列

通過學習，我們知道陣列也有分類，例如
int arr1[10] 為整形陣列，用于存放整數，其中每個元素為 int 型
char arr2[10] 為字符陣列，用于存放字符，其中每個元素為 char 型
除了如這類陣列外，還有指標陣列，具體例如：

int* arr1 [ 10 ] ： //整形指標的陣列，即陣列中的每個元素為整型指標
char * arr2 [ 4 ] ： //一級字符指標的陣列，每個元素為 char* 型的指標

char ** arr3 [ 5 ] ： //二級字符指標的陣列，每個元素為 char** 型的指標

3.陣列指標

在講解陣列指標前，首先介紹一下變數型別
在定義一個變數時，除去陣列名，就是變數型別
例如：

int a = 10; // 除去變數名a，變數型別為int
char ch = ‘w’; // 除去變數名ch，變數型別為char
int* p = NULL; // 除去變數名p，變數型別為int*

對于陣列：

int arr[10] = { 0 }; // 除去變數名 arr，變數型別為 int [10]
int arr[3][4] = { 0 }; // 除去變數名 arr，變數型別為 int [3][4]
int* arr[10] = { 0 }; // 除去變數名 arr，變數型別為 int* [10]

3.1 陣列指標的定義

陣列指標是指標？還是陣列？
答案是：指標
我們已經熟悉：
整形指標： int * pint ; 能夠指向整形資料的指標，
浮點型指標： float * pf ; 能夠指向浮點型資料的指標，
那陣列指標就是：能夠指向陣列的指標，
具體看代碼：

#include<stdio.h>
int main()
{
int arr [10] = { 0 };
int ( *p ) [10] = &arr; // &arr— 取出的為陣列的地址，此時的p就為陣列指標
return 0;
}

解釋：
p 先和 * 結合，說明 p 是一個指標變數，然后指標指向的是一個大小為10個的整型陣列，所以 p 是一個指標，指向一個陣列，叫陣列指標，
這里要注意：
[ ] 的優先級要高于 * 號，所以必須加上（）才能確保 p 先和 * 結合，
這里指標 p 的型別就是 int ( * ) [10]

3.2 陣列名 VS &陣列名

對于一個陣列的陣列名，它什么時候代表陣列首元素的地址？什么時候又代表整個陣列的地址？這里作以下說明
陣列名代表整個陣列只有兩種情況：
1. & 陣列名，如 &arr 即為取出整個陣列的地址
2. sizeof(陣列名)，如 sizeof(arr) ,為計算整個陣列的大小
其他情況下均代表陣列首元素地址，

那么 “ 陣列名 ” 和 “ &陣列名 ” 有什么區別呢?

#include <stdio.h>
int main()
{
int arr[10] = {0};
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}

我們可以看到 arr 和 &arr 的地址的值一樣，即陣列首元素的地址和整個陣列的地址的值是一樣的，那么兩者的的本質是否真的一樣呢？
有如下代碼：

#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("&arr= %p\n", &arr);
printf("arr+1 = %p\n", arr+1);
printf("&arr+1= %p\n", &arr+1);
return 0;
}

根據上面的代碼我們發現，其實 &arr 和 arr ，雖然值是一樣的，但是意義應該不一樣的，
實際上：
&arr 表示的是陣列的地址（是以整個陣列為視角），而不是陣列首元素的地址，陣列的地址+1，跳過整個陣列的大小，所以 &arr+1 相對于 &arr 的差值是40 ，

3.3 陣列指標的使用

我們知道陣列指標指向的是陣列，那陣列指標中存放的應該是陣列的地址，那么對陣列指標解參考就相當于得到了陣列名，
陣列指標簡單的使用案例就是列印二維陣列，具體看如下代碼：

#include<stdio.h>
void print(int(*p)[5], int row, int col)//巧妙的以陣列指標來作為形參
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print(arr, 3, 5);
	return 0;
}

說明：將二維陣列的陣列名傳過去（實質上是將二維陣列的第一個元素，即將三行中的第一行陣列整體傳過去），所以用一個陣列指標接收，該陣列指標指向一個陣列，陣列5個元素，每個元素型別為 int 型，

printf("%d ", ((p + i) + j));其中對于這行代碼的解釋如下：

雖然上述代碼運用了陣列指標，但是列印二維陣列并不建議這樣操作，相對比較麻煩，對于初學者理解起來有一定困難，通常情況下直接傳入形參為一個二維陣列去操作會方便很多，

4.陣列引數、指標引數

4.1 一維陣列傳參

 #include <stdio.h>
void test(int arr[])//ok?  陣列接收，完全OK
{}
void test(int arr[10])//ok?  陣列接收，完全OK
{}
void test(int *arr)//ok?  指標接收，沒問題
{}
void test2(int *arr[20])//ok?  陣列接收，沒問題
{}
void test2(int **arr)//ok?  指標接收，沒問題
//(傳過來的為陣列首元素（一個指標的地址）所以形參為二指標接收沒問題)
{}
int main()
{
int arr[10] = {0};//整型陣列
int *arr2[20] = {0};//整型指標陣列
test(arr);
test2(arr2);
return 0;
}

總結：
對于一維陣列，當傳入函式的實參為陣列名（本質上為陣列首元素地址）時，函式接收的形參可為陣列，也可為指標，

4.2 二維陣列傳參

void test(int arr[3][5])//ok？ 陣列接收，完全OK
{}
void test(int arr[][])//ok？ 二維陣列的形式不知道，不能傳這樣的形參
{}
void test(int arr[][5])//ok？ 知道二維陣列的列數，可以傳入
{}
//總結：二維陣列傳參，函式形參的設計只能省略第一個[]的數字，
//因為對一個二維陣列，可以不知道有多少行，但是必須知道一行多少元素，
//這樣才方便運算，
void test(int *arr)//ok？ No！
//二維陣列的陣列名為第一行的地址，不能用一級指標接收
{}
void test(int* arr[5])//ok？ No！ 引數為指標陣列，不能接收
{}
void test(int (*arr)[5])//ok？ 可以 引數為陣列指標
{}
void test(int **arr)//ok？ No! 實參為陣列名，形參為二級指標，無法接收
{}
int main()
{
int arr[3][5] = {0};
test(arr);//實質上為傳入第一行元素的地址
return 0;
}

總結:
對于二維陣列，當傳入函式的實參為陣列名時，形參可以是同樣形式的陣列名接收，也可用陣列指標接收，

4.3 一級指標傳參

我們知道，當傳入的引數為一級指標時，我們可以用一級指標的形參對其進行接收，那么當函式形參為一級指標的時候，我們可以傳入什么樣的引數呢？

#include<stdio.h>
void test(int* p)
{}
int main()
{
	int a = 10;
	test(&a); // 可以傳入變數的地址
	int* p = &a;
	test(p); // 可以傳入一級指標
	int arr[10] = { 0 };
	test(arr); // 可以傳入一維陣列名
	//...
	return 0;
}

總結：形參為一級指標，那么實參本質上也得為一級指標
所以，實參可為：變數的地址，一級指標，一維陣列名

4.4 二級指標傳參

#include<stdio.h>
void test(int** p)
{}
int main()
{
	int a = 10;
	int* pa = &a;
	test(&pa);//可以傳入一級指標的地址
	int** paa = &pa;
	test(paa);//可以傳入二級指標
	int* arr[10];
	test(arr);//可以傳入一級指標陣列的陣列名
	//...
	return 0;
}

總結：形參為二級指標，那么傳過去的實參實質上得為一級指標的地址
所以，實參可為：一級指標地址，二級指標，一級指標陣列的陣列名（第一行的地址）