一、指針與一維數組

1. 指針與數組基礎

先說明幾點干貨：

1. 數組是變量的集合，并且數組中的多個變量在內存空間上是連續存儲的。

2. 數組名是數組的入口地址，同時也是首元素的地址，數組名是一個地址常量，不能更改。

3. 數組的指針是指數組在內存中的起始地址，數組元素的地址是指數組元素在內存中的其實地址。

??????對于第一點數組中的變量在內存空間上是連續的相信沒有什么疑問，這點在講解數組的時候就已經提到過了。對于第二點，可以得到，數組名就是一個地址，并且是整個數組的內存起始地址。數組名一個是常量地址我們不能對數組名進行賦值操作，數組名是數組的起始地址，數組的第一個元素的地址也是數組的起始地址，他們兩個在數值上是相等的。對于第三點，舉個例子，假如定義一個 int 類型變量 a，int 占四個字節，假如他的第一個字節的地址是 0x00000010, 第四個字節的地址那么就是 0x00000013。而 &a 的地址是 a 的內存空間上的首地址，即 &a 的值為 0x00000010。

??????通過下面示例可以來證明一下上面講述的結論。

源代碼：

#include <stdio.h>
int main()
{
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int b = 20;
    char *pb = &b;
    /*a是地址常量，不能被賦值*/
    //a = pb;
    /*在數值上 a &a[0] &a 的數值是相等的 */
    printf("a = %p, &a[0] = %p, &a = %p\n", a, &a[0], &a);
    printf("&b = %p, pb = %p, pb + 3 = %p\n", &b, pb, pb + 3);
    return 0;
}

運行結果：

a = 0xbfb82f38, &a[0] = 0xbfb82f38, &a = 0xbfb82f38
&b = 0xbfb82f30, pb = 0xbfb82f30, pb + 3 = 0xbfb82f33

2. 指針與數組

以一個實例開始，數組的打印你會幾種方法？

源代碼：

#include <stdio.h>
int main()
{
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int *p = a, i;
//1. 數組元素訪問法
    for (i = 0; i < 10; i++) {
        printf("a[%d] = %-3d", i, a[i]);
    }
    putchar(10);  //等價于 putchar('\n'), 因為 \n 的 ASCII 碼就是 10
//2. 數組地址偏移訪問法
    for (i = 0; i < 10; i++) {
        printf("a[%d] = %-3d", i, *(a + i));
    }
    putchar(10);
//3. 指針元素訪問法
    for (i = 0; i < 10; i++) {
        printf("a[%d] = %-3d", i, p[i]);
    }
    putchar(10);
//4. 指針地址偏移訪問法
    for (i = 0; i < 10; i++) {
        printf("a[%d] = %-3d", i, *(p + i));
    }
    putchar(10);
    return 0;
}

運行結果：

a[0] = 1 ?a[1] = 2 ?a[2] = 3 ?a[3] = 4 ?a[4] = 5 ?a[5] = 6 ?a[6] = 7 ?a[7] = 8 ?a[8] = 9 ?a[9] = 10?
a[0] = 1 ?a[1] = 2 ?a[2] = 3 ?a[3] = 4 ?a[4] = 5 ?a[5] = 6 ?a[6] = 7 ?a[7] = 8 ?a[8] = 9 ?a[9] = 10

a[0] = 1 ?a[1] = 2 ?a[2] = 3 ?a[3] = 4 ?a[4] = 5 ?a[5] = 6 ?a[6] = 7 ?a[7] = 8 ?a[8] = 9 ?a[9] = 10
a[0] = 1 ?a[1] = 2 ?a[2] = 3 ?a[3] = 4 ?a[4] = 5 ?a[5] = 6 ?a[6] = 7 ?a[7] = 8 ?a[8] = 9 ?a[9] = 10

??????從上面可以看到，如果一個指針p指向數組a，那么 a[i]，*(a+i)， p[i]，*(p+i) 這四種寫法是完全等價的，都是訪問數組中第 i+1 個元素。其實數組對于元素的訪問根本上就是地址的偏移，a[i] 之所以能夠訪問到第 i+1 個元素其實他所進行的操作和 *(a+i) 是一樣的，都是在地址 a 的基礎上偏移 i 個單位的內存單元進行元素訪問。a 是一個地址，p 也是一個地址，且當 p 指向 a 的時候，能夠以 a[i] 來訪問第 i+1 元素，那么同理也能以 p[i] 的方式來訪問第 i+1 個元素。同樣的 *(p+i) 也是以地址偏移的方式來進行數組元素的訪問。其實這幾種寫法唯一不同的就是 a 是地址常量，不能被賦值，也就是 a 不被允許再指向其他的內存空間，而 p 是指針變量，可以被任意賦值，可以指向其他的內存空間。

3. 一個思考

通過上面的講解請大家看一下下面程序應該輸出多少？

#include <stdio.h>
int main()
{
    int a[10] = {1, 2, 3, 4, 5};
    int *p = &a[1];
    p[0] = 20;
    p[1] = 30;
    p[-1] = 10;
    printf("a[0] = %d, a[1] = %d, a[2] = %d\n", a[0], a[1], a[2]);
    return 0;
}

??????其實大家可能或許能夠猜到程序的輸出結果是10，20，30。但是可能并不是所有人都能夠清楚的明白編譯器是怎么個處理邏輯的，在這里來為大家再做進一步的講解，讓大家對指針和數組的關系有更深一步的認識。

??????上圖簡單從地址偏移角度來畫出了指針的指向，大家先看右邊，地址 a 在數值上指向數組的首地址，那么 a+1 就是偏移了一個 int 類型，也就是 4 字節，所以 a+1 指向數組的第二個元素。大家再看左邊，p 指向 a[1] 的首地址，那么從指針變量 p 的角度來看，p[0] 就是他指向的元素 a[1]，所以 p[0] 和 a[1] 是完全相等的，呢么 p[1] ,也可以寫成 *(p+1) 指向的就是 a[2] 元素的首地址，因為 p+1 要在 p 的基礎上偏移 4 字節，p 指向 a[1] 的首地址，那么 p+1 就是指向 a[2] 的首地址，再用取值運算符 *(p+1) 的值就是a[2] 的值也就是 3。p+1 理解了那么 p-1 也就不能理解了，他們兩個只是偏移的方向不同，p+1 是向右移，也就是地址增加的方向一定，而 p-1 是向左移，向地址減小的方向移動。

二、指針與字符串

??????C語言處理字符串通常實講字符串放在字符數組中，因為C語言沒有字符串類型，而字符串在地址空間上是連續的，而數組元素在內存空間上也是連續，字符串就是若干字符的集合，所以就用字符數組來處理字符串，對于常量字符串也可以用指針對其直接指向操作。

??????關于指針與字符串的關系大家可以先看看下面程序：

#include <stdio.h>
int main()
{
    char a[] = "hello world";
    char *b = "hello world";
    a[1] = 'z';
    //b[1] = 'z';   //error
    printf("a = %s\n", a);
    return 0;
}

??????其實如上面注釋所示，可以對 a 里面的元素進行賦值操作，而不能對 b 里面的元素進行賦值操作。為什么呢？其實原因與內存單元的分配有關。a 是一個局部變量數組，局部變量分配在棧上，棧上的內容具有可讀可寫操作，所以對 a 里面的元素進行賦值操作沒有問題。而 b 是一個指針，也是一個局部變量，但是 b 指向的是一個字符串常量，字符串常量存儲在只讀區，只讀區里面的內容只有讀權限而沒有寫權限，這點尤其注意，所以我們上述操作中對 b 指向的內容進行寫操作編譯器是會報錯的。報錯內容就是段錯誤。導致段錯誤的原因就是訪問了非法內存，非法內存一般就是內存地址不存在或者對于該塊地址沒有權限。

三、指針和二維數組

1. 指針數組與數組指針

??????該部分主要講解指針數組與數組指針。可能對于初學者而言對指針數組和數組指針比價容易弄混，其實記后面兩個字就可以，指針數組 后面兩個字是數組，說明指針數組是一個數組，那么數組里面存儲的內容就是前兩個字 指針。數組指針 后面兩個字是指針，說明數組指針是一個指針，那么這個指針指向那里，前面兩個字就有體現，數組指針指向一個數組。一句話概括之，指針數組是一個數組，數組里面每個元素存儲的是一個指針；數組指針是一個指針，是指向數組的指針。

指針數組的定義方法：

char a[5]; //字符數組

char *a[5]; //指針數組

數組指針的定義方法：

char a[5]; //字符數組

char (*a)[5] //數組指針

??????上面數組指針和指針數組的定義方法很像，其實不管是這里的指針數組 數組指針 還是后面文章中會講解的 指針函數 函數指針，其實分辨他們有一個訣竅，那就是右左法則，何謂右左法則，即在運算符的優先級范圍內，先往右看，再往左看。打個比方，看上面定義的指針數組，先找到 a ，a 的右邊與 a 結合是一個數組，那么這個定義就是一個數組，是個什么樣的數組呢？再往左看，a 的左邊與 a 結合是一個指針，那么就是一個指針數組。再來看看數組指針，先找到 a，a 的右邊是一個括號，有括號先看括號里面的內容，也就是往左看，括號里面的內容是一個指針，是個什么樣的指針呢？再往右看，是一個數組，所以就是數組指針。掌握了這個方法，不管是給出定義來辨別名字，還是告訴你名字讓其寫出定義都不在話下。

2. 指針數組

??????指針數組是一個數組，里面每個成員都是指針，定義一個指針數組相當于定義了多個指針變量的集合。 例如 int *a[3]; 這是一個指針數組，數組里面每個成員都是指向int類型地址的。為了讓大家更加熟悉指針數組的使用，大家請看下面這個例子：

源代碼：

#include <stdio.h>
int main()
{
    int a = 1, b= 2, c = 3;
    int *p[3];   //定義一個指針數組，數組里面有3個成員，每個成員都是指向int類型的指針。
    /*數組成員的初始化*/
    p[0] = &a;
    p[1] = &b;
    p[2] = &c; 
    /*通過指針改變其指向地址中的內容*/
    *p[0] = 10;
    *p[1] = 20;
    *p[2] = 30;
    printf("a = %d, b = %d, c = %d\n", a, b, c);
    return 0;
}

運行結果：

a = 10, b = 20, c = 30

??????通過上面例子大家就不難發現，定義好指針數組之后，數組成員的使用方法和普通指針的使用是一樣的，定義好一個指針數組唯獨就是可以一次性定義好多個指向相同類型的指針。其實大家想一下，我們當時引入數組的時候說C語言引入數組就是因為數組可以一次性定義好多個具有相同類型的普通變量，其實這里的指針數組也是一樣的，不同的是，普通數組里面的成員都是普通變量，而指針數組里面的成員都是指針。

3. 數組指針

??????數組指針是一個指針，指向一個數組的指針。 例如 int (*a)[3]; 這是一個數組指針，指向的是一個3列的數組，a+1 就相當于步進為1列，1列有3個int類型，相當于步進了 3 * 4 = 12(字節)。示例如下：

源代碼：

#include <stdio.h>
int main(int argc, const char *argv[])
{
	int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	/*定義數組指針*/
	int (*p)[3] = a;
	int (*q)[2] = a;
	/*數組指針步進加1為1行*/
	printf("p = %p, p + 1 = %p\n", p, p+1);
	/*先對行指針進行一次解引用就是普通指針，普通指針步進就是指向的普通數據類型的大小*/
	*(*(p+1) + 1) = 56;
	printf("%d\n", a[1][1]);
	printf("q = %p, q + 1 = %p\n", q, q+1);
	*(*(q+1) + 1) = 56;
	printf("%d\n", a[1][0]);
	return 0;
}

運行結果：

p = 0xbfc208ec, p + 1 = 0xbfc208f8
56
q = 0xbfc208ec, q + 1 = 0xbfc208f4
56

圖示如下：

??????數組指針的步進大家一定要清楚，步進主要看定義時數組個數的大小，比如 int (*p)[3]; 步進加1就是步進 int [3] 大小；int (*q)[2]; 步進加1就是 int [2] 大小。數組指針就是行指針，因為數組指針指向相同行的數組時，指針偏移加1就是1行。