引言：在前面的c語言_指針初階上，我們了解了簡單的指針類型以及使用，下面我們將進入更深層次的指針學習，對指針的理解會有一個極大的提升。從此以后，指針將不再是難點，而是學習底層語言的一把利器。

本章重點

• 字符指針
• 數(shù)組指針
• 指針數(shù)組
• 數(shù)組傳參和指針傳參
• 函數(shù)指針
• 函數(shù)指針數(shù)組
• 指向函數(shù)指針數(shù)組的指針
• 回調函數(shù)
• 指針和數(shù)組面試題的解析

指針的主題，我們在初級階段的《指針》章節(jié)已經(jīng)接觸過了，我們知道了指針的概念：

1. 指針就是個變量，用來存放地址，地址唯一標識一塊內存空間。

2. 指針的大小是固定的4/8個字節(jié)（32位平臺/64位平臺）。

3. 指針是有類型，指針的類型決定了指針的±整數(shù)的步長，指針解引用操作的時候的權限。

4. 指針的運算。

這個章節(jié)，我們繼續(xù)探討指針的高級主題。

1. 字符指針

在指針的類型中我們知道有一種指針類型為字符指針char*;

一般使用:

int main()
{char ch = 'w';char *pc = &ch;*pc = 'w';return 0;
}

還有一種使用方式如下：

int main()
{char* pstr = "hello bit.";//這里是把一個字符串放到pstr指針變量里了嗎？printf("%s\n", pstr);return 0;
}

代碼char* pstr = "hello bit."；特別容易讓同學以為是把字符串hello bit 放到字符指針了，但是本質是把字符串pstr 里hello bit，首字符的地址放到了pstr中。

類似于int arr[3] = {1, 2, 3}; int* parr = arr。我們知道數(shù)組名就是首元素地址，那么將數(shù)組名當作地址存入parr的指針變量中。

我們可以看到結果確實是把字符串的首元素地址存儲在了parr指針變量中。

一道面試題：

輸出結果：

為什么會產(chǎn)生出這種結果？
通俗易懂來說,str1以及str2它們各自開辟了一塊空間，然后都拿了相同的字符串進行存儲，那么即便值相同，地址卻是不相同的。
str3和str4都指向了一塊常量，我們知道常量是不可以被修改的，所以也沒必要產(chǎn)生出兩個指針指向同一個常量，由此可得，str3 == str4。
所以這里的區(qū)別就是：一個是存儲值，一個是指向常量。

當我們往下面學習指針數(shù)組和數(shù)組指針的時候，就會產(chǎn)生一種沒來由的困惑，讀起來都有點繞口。其實辨別起來很簡單：只需要去看最后兩個字是什么。

指針數(shù)組：數(shù)組，裝有指針元素的數(shù)組
數(shù)組指針：指針，指向數(shù)組的指針

2. 指針數(shù)組

在C語言_指針_初階章節(jié)，我們也學了指針數(shù)組，指針數(shù)組是一個存放指針的數(shù)組。

這里我們再復習一下，下面指針數(shù)組是什么意思？

int* arr1[10]; //整形指針的數(shù)組
char *arr2[4]; //一級字符指針的數(shù)組
char **arr3[5];//二級字符指針的數(shù)組

通過指針數(shù)組模擬實現(xiàn)二維數(shù)組

3. 數(shù)組指針

3.1 數(shù)組指針的定義

數(shù)組指針是指針？還是數(shù)組？

答案是：指針。

我們已經(jīng)熟悉了：整型指針：int* ptr；能夠指向整形數(shù)據(jù)的指針。浮點型指針：float* ptr；能夠指向浮點型數(shù)據(jù)的指針。

那數(shù)組指針也就很明確了：指向數(shù)組的指針。

下面代碼哪個是數(shù)組指針？

int *p1[10];
//p1先跟[]結合，說明他是數(shù)組,[]里面是10，說明裝有10個整型指針的元素。
int (*p2)[10];//數(shù)組指針//p1, p2分別是什么？

畫圖詳解

解釋：

首先，p和先做結合，也就是( * p)，說明p是指針變量，然后外面還剩下int [10]，這個我們之前見過，也就是裝有10個整型元素的數(shù)組。那么好像就能合起來解釋了，也就是指向裝有10個整型元素的數(shù)組的指針。
總結：p是指針，指向一個數(shù)組，也就是數(shù)組指針。
這里需要注意的是：[]的優(yōu)先級是要高于 * 號的，所以必須加上（）來保證p先和結合。

3.2 &數(shù)組名 VS 數(shù)組名

對于下面的數(shù)組：

int arr[10];

arr 和 &arr 分別是啥？

我們知道arr是數(shù)組名，數(shù)組名表示數(shù)組首元素的地址。

那&arr數(shù)組名到底是啥？

我們看一段代碼：

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

輸出結果

可見數(shù)組名和&數(shù)組名打印的地址是一樣的。

難道兩個是一樣的嗎？

我們再看一段代碼：

#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;
}

輸出結果

根據(jù)上面的代碼我們發(fā)現(xiàn)，其實&arr和arr，雖然值是一樣的，但是意義應該是不一樣的。
實際上：&arr 表示的是數(shù)組的地址，而不是數(shù)組首元素的地址。（細細體會一下）
數(shù)組的地址+1，跳過整個數(shù)組的大小，所以&arr+1 相對于 &arr 的差值是40。

從上面可知，數(shù)組名就是首元素的地址，那么sizeof(數(shù)組名)，難道取的是指針變量的字節(jié)嘛？

由此可得，sizeof(數(shù)組名)并不是取得首元素地址的字節(jié)；這里的數(shù)組名代表了整個數(shù)組，也就是取得是整個數(shù)組的地址。

我們可以看到雖然表達出來的結果完全一樣，但內在的意義確實完全不相同。

總結：

數(shù)組名大部分情況下都是首元素地址，但有兩個例外，如下：

1.sizeof（數(shù)組名），這里面的數(shù)組名代表的是整個數(shù)組，所以取出來的字節(jié)也就是整個數(shù)組的字節(jié)。

2.&數(shù)組名，這里的數(shù)組名代表的也是整個數(shù)組，那么取出來的地址也就是整個數(shù)組的地址。

3.3 數(shù)組指針的使用

那數(shù)組指針是怎么使用的呢？

既然數(shù)組指針指向的是數(shù)組，那數(shù)組指針中存放的應該是數(shù)組的地址。

下面我們通過數(shù)組指針完成對數(shù)組內的元素進行一個遍歷。

畫圖詳解

上面我們講述了一維數(shù)組取地址變成數(shù)組指針的使用方式，下面我們來講述二維數(shù)組取地址變成數(shù)組指針的使用方式，并且會畫圖詳細的描述整個流程。

畫圖詳解 -> 分批次詳細解讀針對二維數(shù)組取地址變成數(shù)組指對內部的值進行訪問的一個過程

4. 數(shù)組參數(shù)、指針參數(shù)

4.1 一維數(shù)組傳參

#include <stdio.h>
void test(int arr[])//ok?
//實參傳遞了數(shù)組名，形參就可以用數(shù)組類型進行接受
{}
void test(int arr[10])//ok?
//完全沒問題
{}
void test(int *arr)//ok?
//指向int類型元素的地址，也就是指向首元素的地址。
{}
void test2(int *arr[20])//ok?
//完全沒問題
{}
void test2(int **arr)//ok?
//(*arr)是一個指針，指向了一個int*類型的元素。
{}int main()
{int arr[10] = {0};int *arr2[20] = {0};test(arr);test2(arr2);
}

4.2 二維數(shù)組傳參

void test(int arr[3][5])//ok？
//完全沒問題
{}
void test(int arr[][])//ok？
//不能省略一維數(shù)組中存儲元素的個數(shù)。
{}
void test(int arr[][5])//ok？
//正確，可以省略二維數(shù)組的一維元素個數(shù)。
{}
//總結：二維數(shù)組傳參，函數(shù)形參的設計只能省略第一個[]的數(shù)字。
//因為對一個二維數(shù)組，可以不知道有多少行，但是必須知道一行多少元素。
//這樣才方便運算。
void test(int *arr)//ok？
//錯誤，形參的意思是指向整型元素的地址，跟題意完全不同。
{}
void test(int* arr[5])//ok？
//錯誤，形參是指針數(shù)組的意思，跟題意完全不同。
{}
void test(int (*arr)[5])//ok？
//正確，(*arr)是指針，指向了一個裝有五個整型元素的數(shù)組。
{}
void test(int **arr)//ok？
//錯誤，首元素地址代表的是一維數(shù)組的整個數(shù)組地址。
{}int main()
{int arr[3][5] = {0};test(arr);
}

一級指針傳參

#include <stdio.h>
void print(int *p, int sz)
{int i = 0;for(i=0; i<sz; i++){printf("%d\n", *(p+i));}
}int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一級指針p，傳給函數(shù)print(p, sz);return 0;
}

當一個函數(shù)的參數(shù)部分為一級指針的時候，函數(shù)能接收什么參數(shù)？

void test(char* ptr)
{}int main()
{char arr[10] = "abcdef";char ch = 'a';char* ptr = arr;test(arr);test(&ch);test(ptr);return 0;
}

二級指針傳參

#include <stdio.h>
void test(int** ptr)
{printf("num = %d\n", **ptr);    
}int main()
{int n = 10;int*p = &n;int **pp = &p;int* arr[5];test(pp);test(&p);test(arr);return 0;
}

5. 函數(shù)指針

首先，我們看最后兩位是指針，那么他其實就是指向函數(shù)的指針。

輸出的是兩個地址，這兩個地址是test函數(shù)的地址。 那我們的函數(shù)的地址要想保存起來，怎么保存？

下面我們看代碼：

void test(char* pc, int arr[10])
{}int main()
{void (*ptr)(char*, int [10]) = &test;//&test跟test都能表達地址，可以省略&。return 0;
}

首先*和ptr先結合，說明它是指針，指向的是一個函數(shù)，里面有char*的類型和int [10] 類型，這個函數(shù)的類型是void類型。
總結：指向了一個void類型函數(shù)里面參數(shù)有char*類型以及int[10]類型的指針。

那么，我們既然知道了函數(shù)指針怎么創(chuàng)建，那下面我們就繼續(xù)討論，怎么使用函數(shù)指針。

看起來我們好像知道了該怎么使用函數(shù)指針進行傳參了，上面我們已經(jīng)了解了pf就是函數(shù)地址,但是，這里的(*pf)并不是對pf做一個解引用的訪問，在函數(shù)指針中，函數(shù)名 == &函數(shù)名，也就是說這里的*號僅僅起到裝飾的作用，并不能跟解引用訪問串聯(lián)起來。

聰明的朋友已經(jīng)看出來了，add和&add都是代表著函數(shù)地址的意思，那么pf好像等價于add，那有沒有可能pf(參數(shù)1，參數(shù)2)也可以進行函數(shù)調用呢？

看起來跟我們的想法是正確的。

閱讀兩段有趣的代碼：

 (*(void (*)())0)();

畫圖詳解

 void (*signal(int , void(*)(int)))(int);

畫圖詳解

在做一個類似的題目再次進行鞏固所學的知識

6. 函數(shù)指針數(shù)組

數(shù)組是一個存放相同類型數(shù)據(jù)的存儲空間，那我們已經(jīng)學習了指針數(shù)組， 比如：

int *arr[10];
//數(shù)組的每個元素是int*

那要把函數(shù)的地址存到一個數(shù)組中，那這個數(shù)組就叫函數(shù)指針數(shù)組，那函數(shù)指針的數(shù)組如何定義呢？

int (*parr1[10]])();

parr1先和[]結合，說明它是一個數(shù)組，數(shù)組里面裝有10個int(*)()函數(shù)類型元素。

那么我們從這里就明白了，函數(shù)指針數(shù)組的寫法，那么我們開拓一下思路，是不是也就知道了數(shù)組指針數(shù)組的寫法？

int arr_1[5] = { 1, 2, 3, 4, 5 };
int arr_2[5] = { 1, 2, 3, 4, 5 };
int arr_3[5] = { 1, 2, 3, 4, 5 };
int (*parr[3])[5] = {&arr_1, &arr_2, &arr_3};

parr先和[3]結合，說明parr是一個數(shù)組，里面裝有三個指向裝有5個int類型元素的數(shù)組的指針
聽著可能有些繞口，我們把這段話再次拆開來細細分析。
我們就先看里面的內容，簡單來說是不是就是指向數(shù)組的指針？然后數(shù)組里面有三個元素都是這樣的類型。

函數(shù)指針數(shù)組的用途：轉移表

例子：（計算器）

//加法
int add(int x, int y)
{return x + y;
}//減法
int sub(int x, int y)
{return x - y;
}//乘法
int mul(int x, int y)
{return x * y;
}//除法
int div(int x, int y)
{return x / y;
}void menu()
{printf("****************************\n");printf("*****  1.add    2.sub  *****\n");printf("*****  3.mul    4.div  *****\n");printf("*****  0.exit          *****\n");printf("****************************\n");
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("請選擇：");scanf("%d", &input);switch (input){case 1:printf("請輸入兩個數(shù)字：");scanf("%d %d", &x, &y);ret = add(x, y);printf("ret = %d\n", ret);break;case 2:printf("請輸入兩個數(shù)字：");scanf("%d %d", &x, &y);ret = sub(x, y);printf("ret = %d\n", ret);break;case 3:printf("請輸入兩個數(shù)字：");scanf("%d %d", &x, &y);ret = mul(x, y);printf("ret = %d\n", ret);break;case 4:printf("請輸入兩個數(shù)字：");scanf("%d %d", &x, &y);ret = div(x, y);printf("ret = %d\n", ret);break;case 0:printf("退出計算器！！！\n");break;default:printf("輸入錯誤，請重新選擇！！！\n");break;}} while (input);return 0;
}

雖然實現(xiàn)了計算器項目，但是可以看到代碼中出現(xiàn)了大量重復的代碼，顯得十分冗余。

所以，衍生出了下面的這個方式，使用函數(shù)指針數(shù)組實現(xiàn)計算器：

//加法
int add(int x, int y)
{return x + y;
}//減法
int sub(int x, int y)
{return x - y;
}//乘法
int mul(int x, int y)
{return x * y;
}//除法
int div(int x, int y)
{return x / y;
}void menu()
{printf("****************************\n");printf("*****  1.add    2.sub  *****\n");printf("*****  3.mul    4.div  *****\n");printf("*****  0.exit          *****\n");printf("****************************\n");
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;//函數(shù)指針數(shù)組int (*PfArr[5])(int, int) = {NULL, add, sub, mul, div};do{menu();printf("請選擇：");scanf("%d", &input);if (input >= 1 && input <= 4){printf("請輸入兩個數(shù)字：");scanf("%d %d", &x, &y);//通過函數(shù)指針數(shù)組調用函數(shù) - 轉移表//通過函數(shù)指針數(shù)組找到對應下標然后跳到該函數(shù)位置得到結果再次返回來。int ret = (*PfArr[input])(x, y);printf("ret = %d\n", ret);}else if (input == 0){printf("退出計算器！！！\n");}else{printf("輸入有誤，請重新檢查！！！\n");}} while (input);return 0;
}

可以明顯的感受到代碼進行了簡化。

7. 指向函數(shù)指針數(shù)組的指針

其實很好理解，指針指向了一個數(shù)組，數(shù)組里面的元素都是函數(shù)指針。

void test(const char* str)
{printf("%s\n", str);
}int main()
{//函數(shù)指針void(*pf)(const char*) = &test;//函數(shù)指針數(shù)組void(*pf[5])(const char*);//指向函數(shù)指針數(shù)組的指針void(*(*pf)[5])(const char*);//再次拓展//指向函數(shù)指針數(shù)組的指針的數(shù)組void(*(*pf[5])[5])(const char*);return 0;
}

8. 回調函數(shù)

回調函數(shù)就是一個通過函數(shù)指針調用的函數(shù)。如果你把函數(shù)的指針（地址）作為參數(shù)傳遞給另一個函數(shù)，當這個指針被用來調用其所指向的函數(shù)時，我們就說這是回調函數(shù)?；卣{函數(shù)不是由該函數(shù)的實現(xiàn)方直接調用，而是在特定的事件或條件發(fā)生時由另外的一方調用的，用于對該事件或條件進行響應。

畫圖詳解：

那我們知道了回調函數(shù)的概念，通過回調函數(shù)來繼續(xù)實現(xiàn)計算器項目

//加法
int add(int x, int y)
{return x + y;
}//減法
int sub(int x, int y)
{return x - y;
}//乘法
int mul(int x, int y)
{return x * y;
}//除法
int div(int x, int y)
{return x / y;
}//菜單
void menu()
{printf("****************************\n");printf("*****  1.add    2.sub  *****\n");printf("*****  3.mul    4.div  *****\n");printf("*****  0.exit          *****\n");printf("****************************\n");
}//在特定條件下通過傳遞過來的地址作為媒介去調用函數(shù)
void Cacl(int(*pf)(int, int))
{int x = 0;int y = 0;printf("請輸入兩個數(shù)字：");scanf("%d %d", &x, &y);int ret = (*pf)(x, y);printf("ret = %d\n", ret);
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("請選擇：");scanf("%d", &input);switch (input){case 1:Cacl(add);break;case 2:Cacl(sub);break;case 3:Cacl(mul);break;case 4:Cacl(div);break;case 0:printf("退出計算器！！！\n");break;default:printf("輸入有誤，請重新輸入！！！\n");break;}} while (input);return 0;
}

通過回調函數(shù)的方式完成計算器項目，代碼也是得到了很大的簡化。

下面在講qsort之前，我們先了解一下冒泡排序的思路。

其實冒泡排序的核心思路不難，就是通過相鄰兩個數(shù)字進行對比，不斷的將一個最大值或者最小值挪到最右邊，以上僅僅是一趟，我們要通過多躺實現(xiàn)最終的效果。

我們將冒泡排序再次復習一遍。

//冒泡排序
void Bubble_sort(int* arr, int sz)
{int i = 0;//趟數(shù)for (i = 0; i < sz - 1; i++){int j = 0;//一趟比較的次數(shù)for (j = 0; j < sz - 1 - i; j++){//相鄰兩個數(shù)字進行比對if (arr[j] < arr[j + 1]){//三個空杯子原理進行交換int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}
}//輸出排序結果
void Printf(int* arr, int sz)
{int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}int main()
{int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };int sz = sizeof(arr) / sizeof(arr[0]);Bubble_sort(arr, sz);Printf(arr, sz);return 0;
}

輸出結果：

首先演示一下qsort函數(shù)的使用：

#include <stdlib.h>
#include <string.h>//void*指針 - 無具體類型指針
// void*指針可以接受任意類型的指針
//void*類型指針不能直接進行解引用訪問
//也不能直接用來進行指針運算//整型數(shù)組通過整型元素比較
int cmp_int(const void* p1, const void* p2)
{return *(int*)p2 - *(int*)p1;
}//輸出結果
void Printf(int* arr, int sz)
{int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}//測試qsort排序整型
void test1()
{int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(int), cmp_int);Printf(arr, sz);
}//測試qsort排序結構體
typedef struct Stu Stu;
struct Stu
{char name[20];int age;
};//結構體通過年齡比較
int cmp_stu_by_age(const void* p1, const void* p2)
{return (((Stu*)p1)->age - ((Stu*)p2)->age);
}//結構體通過名字比較
int cmp_stu_by_name(const void* p1, const void* p2)
{//名字不能直接相減，需要通過專門的字符比較函數(shù) - strcmpreturn strcmp(((Stu*)p1)->name, ((Stu*)p1)->name);
}void test2()
{Stu arr[3] = { {"XingC", 22}, {"qmx_07", 20}, {"Yuu", 21}};int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);printf("%d\n", arr[2].age);
}void test3()
{Stu arr[3] = { {"XingC", 22}, {"qmx_07", 20}, {"Yuu", 21} };int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);int i = 0;for (i = 0; i < 3; i++){printf("name = %s\tage = %d\n", arr[i].name, arr[i].age);}
}int main()
{test1();test2();test3();return 0;
}

使用回調函數(shù)，模擬實現(xiàn)qsort（采用冒泡的方式）。

問題一：傳統(tǒng)冒泡排序我們會用整型數(shù)組類型接收，那么我們想模擬實現(xiàn)快排，那就不能固定使用整型數(shù)組類型
問題二：傳統(tǒng)冒泡排序比較使用大小符號比較的，那么結構體如何使用大小符號比較呢？
問題三：傳統(tǒng)冒泡排序符合條件進行交換是通過三個杯子交換實現(xiàn)的，但是不同的數(shù)據(jù)交換略有差異。

//交換
//因為我們不知道我們要交換的類型是什么，所以以最小字節(jié)來進行一一交換最合適不過
//我們還是需要知道這個類型的字節(jié)多少，所以傳入了一個sz
void Swap(char* buf1, char* buf2, int sz)
{int i = 0;//我們知道字節(jié)大小的情況下，循環(huán)交換兩數(shù)的每個字節(jié)for (i = 0; i < sz; i++){char tmp = *(buf1 + i);*(buf1 + i) = *(buf2 + i);*(buf2 + i) = tmp;}
}void Bubble_sort(const void* base, int num, int sz, int (*cmp)(const void*, const void*))
{int i = 0;for (i = 0; i < num - 1; i++){int j = 0;for (j = 0; j < num - 1 - i; j++){//通過我們自己寫的比較函數(shù)來判斷是否符合條件if ((*cmp)((char*)base + j * sz, (char*)base + (j + 1) * sz) > 0){//交換Swap((char*)base + j * sz, (char*)base + (j + 1) * sz, sz);}}}
}//定義結構體
typedef struct Stu Stu;
struct Stu
{char name[20];int age;
};//結構體年齡成員比較方式
int cmp_stu_by_age(const void* p1, const void* p2)
{return (((Stu*)p1)->age - ((Stu*)p2)->age);
}//結構體名字成員比較方式
int cmp_stu_by_name(const void* p1, const void* p2)
{return strcmp(((Stu*)p1)->name, ((Stu*)p2)->name);
}//測試Bubble_sort 排序結構體數(shù)據(jù)
void test_2()
{Stu arr[3] = { {"XingC", 22}, {"qmx_07", 20}, {"Yuu", 21} };int sz = sizeof(arr) / sizeof(arr[0]);Bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);int i = 0;for (i = 0; i < sz; i++){printf("name = %s\tage = %d\n", arr[i].name, arr[i].age);}
}//整型比較方式
int cmp_int(const void* p1, const void* p2)
{return *(int*)p1 - *(int*)p2;
}//測試Bubble_sort 排序整型數(shù)據(jù)
void test_1()
{int arr[10] = {5, 7, 2, 3, 9, 1, 6, 8, 4, 10};int sz = sizeof(arr) / sizeof(arr[0]);//cmp_int是函數(shù)名；實參傳入函數(shù)名，形參接收函數(shù)的類型Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}int main()
{/*test_1();*/test_2();return 0;
}

9. 指針和數(shù)組筆試題解析

畫圖詳解

對于指針來說，類型只是一個環(huán)節(jié)，最重要的是你要知道指針指向哪里。

總結：

1. sizeof(數(shù)組名)，這里的數(shù)組名表示整個數(shù)組，計算的是整個數(shù)組的大小。
2. &數(shù)組名，這里的數(shù)組名表示整個數(shù)組，取出的是整個數(shù)組的地址。
3. 除此之外所有的數(shù)組名都表示首元素的地址。

10. 指針筆試題

輸出結果：

總結：

• 當我們能學到這里的時候，想必已經(jīng)對指針了解的比較深入了，縱觀整個指針的學習過程中，其實一直繞不開的就是指針類型，最重要的也就是指針類型，我們一直圍繞的也就是指針類型。

• 其實指針就是一個指向或者是一個地址，當不需要進行任何操作的時候，就可以用void*替代，但涉及到任何運算以及解引用操作權限都需要指針類型。

• 當我們能徹底搞清楚我們指針的類型的時候，那么也就對解引用操作以及運算移動操作都將非常清晰，讓我們在底層的訪問中無往不利。

本章完~