重溫C語言(4)之數組與指針

原文：https://mp.weixin.qq.com/s/0WTjpyfQnT9fNciFy-oP1A

數組

數組由一系列相同數據類型的元素組成。

初始化

void initArrayTemp() {
    // 含有 40 個char 類型的數據， 方括號中的數字表明數組中元素的個數
    char name[40];
    // 含有 8 個 int 類型的數據， 初始化了 8 個元素
    int a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
    // 數組元素下標從0開始，a[0] 代表第一個元素
    printf("%d\n", a[1]);

    printf("初始化值小於數組個數：\n");
    // 初始化的元素少於數組個數，那麼剩餘的值存儲的垃圾值，初始化爲0
    int b[4] = {8};
    for (int i = 0; i < 4; ++i) {
        printf("%d ", b[I]);
    }
    printf("\n初始化值大於數組個數：\n");
    // 初始化的元素大於數組個數，去調用的話會直接報錯
    int c[4] = {8, 1, 2, 3, 4, 5, 6, 77};
    for (int i = 0; i < 15; ++i) {
        printf("%d ", c[I]);
    }
    printf("\n不設定數組個數:\n");
    // 如果初始化數組時省略方括號中的數字，編譯器會根據初始化列表中的項數來確定數組的大小
    int d[] = {1, 2, 3, 4, 5, 6, 9, 11, 23};
    // sizeof運算符給出它的運算對象的大小（以字節爲單位）。所以sizeof(d)是整個數組的大小（以字節爲單位），sizeof(d[0])是數組中一個元素的大小（以字節爲單位）。整個數組的大小除以單個元素的大小就是數組元素的個數。
    for (int j = 0; j < sizeof(d) / sizeof(d[0]); ++j) {
        printf("%d ", d[j]);
    }

    printf("\n指定初始化某個元素:\n");
    // 在初始化列表中使用帶方括號的下標指明待初始化的元素
    int e[15] = {1, 2, [3] = 9, [9] = 88, [14] = 3};
    for (int k = 0; k < 15; ++k) {
        printf("%d ", e[k]);
    }
}

2
初始化值小於數組個數：
8 0 0 0 
初始化值大於數組個數：
8 1 2 3 8 0 0 0 1 2 3 4 5 6 7 
不設定數組個數:
1 2 3 4 5 6 9 11 23 
指定初始化某個元素:
1 2 0 9 0 0 0 0 0 88 0 0 0 0 3 

賦值

    int a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
    for (int i = 0; i < 8; ++i) {
        printf("%d ", a[I]);
    }
    printf("\n給下標爲3的第四個元素賦值\n");
    a[3] = 78;
    for (int i = 0; i < 8; ++i) {
        printf("%d ", a[I]);
    }

1 2 3 4 5 6 7 8 
給下標爲3的第四個元素賦值
1 2 3 78 5 6 7 8 

多維數組

    // 含6個數組元素的數組，每個數組元素內含12個int類型的元素
    int a[6][12]  = {
            {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
            {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
            {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
            {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
            {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
            {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
    };

    for (int i = 0; i <5; ++i) {
        printf("\n");
        for (int j = 0; j < 12; ++j) {
            printf("a[%d][%d]=%d  ", i, j, a[i][j]);
        }
    }

 printf("\n多維數組賦值1\n");
    int b[2][3] = {{1,2}, {2, 3}};
    for (int k = 0; k < 2; ++k) {
        for (int i = 0; i < 3; ++i) {
            printf("b[%d][%d]=%d  ", k, i, b[k][I]);
        }
    }

    printf("\n多維數組賦值2\n");
    int e[2][3] = {1,2, 2, 3};
    for (int k = 0; k < 2; ++k) {
        for (int i = 0; i < 3; ++i) {
            printf("e[%d][%d]=%d  ", k, i, e[k][I]);
        }
    }

多維數組賦值1
b[0][0]=1  b[0][1]=2  b[0][2]=0  b[1][0]=2  b[1][1]=3  b[1][2]=0  
多維數組賦值2
e[0][0]=1  e[0][1]=2  e[0][2]=2  e[1][0]=3  e[1][1]=0  e[1][2]=0 

指針

指針提供了一種以符號形式使用地址的方法，能夠更有效的處理數組。

• 指針的值是它所指向對象的地址；
• 在指針前面使用 *運算符可以得到指針指向的對象的值；
• 指針加1的值是指針的值增加它指向的類型的大小（字節）；

數組名是數組首元素的地址：

    int a[10] = {1, 3, 4};  // a 是數組 a 的首元素地址 &a[0]
    printf("%p", a); // 通常以十六進制 %p 來表示元素指針的值: 0x7ffee9b61ae0
     
    int *addrA = a;  // 可以把指針地址賦值給指針變量
    printf("%p\n", addrA);  // 0x7ffee9b61ae0

a 和 &a[0] 都表示數組首元素的內存地址，而且都是常量。這個地址值可以賦值給指針變量。

    printf("a + 1 = %p\n", a + 1); // 0x7ffee7730ae4
    printf("a + 2 = %p\n", a + 2); // 0x7ffee7730ae8

c 語言中，指針加1指增加一個存儲單元。 int 佔4字節，所以數組中指針加1指的是下一個元素的地址。指針所指向對象的類型一定要知道，這樣才能知道存儲單元的大小，

printf("%p = %p\n", (a + 2), &a[2]); // 0x7ffee2fc0ae8 = 0x7ffee2fc0ae8
printf("%d = %d", *(a + 2), a[2]); // 4 = 4

知道正確的存儲單元大小，*a 才能正確的取回地址對應的值。

函數與指針

// 這個方法的參數是數組的首元素地址, 也可以使用 int a[] 代替更能明確聲明的是一個數組形參
int sumArray(int *a, int arraySize){
    int total = 0;
    int i = 0;
    for (i = 0; i < arraySize ; ++i) {
        total += a[i]; // a[i] == *(a + i)
    }
    return total;
}

   int a[5] = {1, 2, 3, 4, 5};
    printf("total = %d", sumArray(a, 5)); // total = 15

可以在函數中修改傳入的數組的元素值

void resetArrayToZero(int a[], int arraySize){
    printf("\nreset array to zero:\n");
    for (int i = 0; i < arraySize; ++i) {
        a[i] = 0;   // 相當與直接修改地址對應的值，即原始數據的內容會被修改
    }
}

 int b[5] = {2, 3, 4, 5, 1};
    printf("\noriginal array to zero:\n");
    for (int i = 0; i < 5; ++i) {
        printf("%d ", b[I]);
    }
    resetArrayToZero(b, 5);
    for (int i = 0; i < 5; ++i) {
        printf("%d ", b[I]);
    }

original array to zero:
2 3 4 5 1 
reset array to zero:
0 0 0 0 0 

可以用指針修改數組之外類型的值：

    printf("\n修改值：\n");
    int number = 4;
    changeNumber(number);
    printf("changeNumber(int a) -> %d\n", number);
    changeNumberByPointer(&number);
    printf("changeNumberByPointer(int * a) -> %d\n", number);

修改值：
changeNumber(int a) -> 4
changeNumberByPointer(int * a) -> 16

指針騷操作

1. 賦值：地址賦給指針 int attr = &number;
2. 解引用：* 號運算符能得到指針指向地址上存儲的值；
3. 取址：指針變量也有自己的地址和值；
4. 指針與整數相加：整數和指針指向的類型大小字節相乘，將結果與指針存儲的地址相加；
5. 遞增指針：遞增指向數組元素的指針可以讓該指針移動至數組的下一個元素；
6. 指針與整數相減：同4，不過是結果相減；
7. 遞減指針：同5；
8. 指針求差：計算兩個指針的差值，可以得到數組兩個元素的距離，也就可以計算出數組指定類型的大小，兩個指針指向同一個數組，這樣求差纔有意義；
9. 用關係運算符可以比較兩個指針的值，前提是兩個指針都指向相同類型的對象。

形式參數使用 const

int sum(const int ar[], int n); /*函數原型*/
int sum(const int ar[], int n) /*函數定義*/ 
{
    int I;
    int total = 0;
    for( i = 0 ; i < n ; i++) 
        total + = ar[i];
    return total;
}

形式參數使用 const，指明該參數只讀，不能被修改，一旦修改就會編譯報錯。

指向多維數組的指針

int (*pz)[2]; //pz指向一個內含兩個int類型值的數組

int *pax[2]; //pax是一個內含兩個指針元素的數組，每個元素都指向int的指針, 中括號的優先級高於 * 

int zippo[4][2] = {{2,4},{6,8},{1,3},{5,7}};
int (*pz)[2];
pz = zippo;

zippo[m][n] == *(*(zippo + m) + n)
pz[m][n] == *(*(pz + m) + n) 

pz[0][0] = 2
*pz[0] = 2
**pz = 2
pz[2][1] = 3
*(*(pz + 2) + 1) = 3

複合字面量

字面量是除符號常量外的常量。例如，43是int類型字面量，11.3是double類型的字面量，'B'是char類型的字面量，"victor"是字符串字面量。

int a[2] = {1, 2};

(int [2]){1, 2};  // 複合字面量，與數組a相同，是匿名數組，小括號中的 `int [2]` 是複合字面量的類型名

(int []{1, 2, 3}); // 初始化有數組名的數組時可以省略數組大小，複合字面量也可以省略大小，編譯器會自動計算數組當前的元素個數

因爲複合字面量是匿名的，所以不能先創建然後再使用它，必須在創建的同時使用它。

int *pt1;
pt1 = (int [2]){10, 20};

小結

數組屬於派生類型，因爲它是建立在其他類型的基礎上使用的。通常會使用函數來處理數組，在把數組名作爲實際參數時，傳遞給函數的不是整個數組，而是數組的地址（因此，函數對應的形式參數是指針）。
要明確數組，指針的基本概念保持頭腦清晰，這樣才能輕鬆應對多維數組。