一、C語言基礎(chǔ)知識入門

C語言一經(jīng)出現(xiàn)就以其功能豐富、表達(dá)能力強(qiáng)、靈活方便、應(yīng)用面廣等特點(diǎn)迅速在全世界普及和推廣。C語言不但執(zhí)行效率高而且可移植性好，可以用來開發(fā)應(yīng)用軟件、驅(qū)動、操作系統(tǒng)等。C語言也是其它眾多高級語言的鼻祖語言，所以說學(xué)習(xí)C語言是進(jìn)入編程世界的必修課！

【資料圖】

需 要 PDF版 和 詳 細(xì) 教 程 的可以看一下文章結(jié)尾

二、C語言的具體結(jié)構(gòu)

簡單來說，一個C程序就是由若干頭文件和函數(shù)組成。

#include就是一條預(yù)處理命令, 它的作用是通知C語言編譯系統(tǒng)在對C程序進(jìn)行正式編譯之前需做一些預(yù)處理工作。

函數(shù)就是實(shí)現(xiàn)代碼邏輯的一個小的單元。

三、主函數(shù)

一個C程序有且只有一個主函數(shù)，即main函數(shù)。

C程序就是執(zhí)行主函數(shù)里的代碼，也可以說這個主函數(shù)就是C語言中的唯一入口。而main前面的int就是主函數(shù)的類型.printf()是格式輸出函數(shù)，這里就記住它的功能就是在屏幕上輸出指定的信息return是函數(shù)的返回值，根據(jù)函數(shù)類型的不同，返回的值也是不同的。\n是轉(zhuǎn)義字符中的換行符。(注意：C程序一定是從主函數(shù)開始執(zhí)行的)

四、規(guī)范

一個說明或一個語句占一行，例如：包含頭文件、一個可執(zhí)行語句結(jié)束都需要換行。函數(shù)體內(nèi)的語句要有明顯縮進(jìn)，通常以按一下Tab鍵為一個縮進(jìn)。括號要成對寫，如果需要刪除的話也要成對刪除。當(dāng)一句可執(zhí)行語句結(jié)束的時候末尾需要有分號。代碼中所有符號均為英文半角符號。

五、程序解釋——注釋

注釋是寫給程序員看的，不是寫給電腦看的。

C語言注釋方法有兩種：

六、C的標(biāo)識符

C語言規(guī)定，標(biāo)識符可以是字母(A～Z，a～z)、數(shù)字(0～9)、下劃線_組成的字符串，并且第一個字符必須是字母或下劃線。在使用標(biāo)識符時還有注意以下幾點(diǎn)：

標(biāo)識符的長度最好不要超過8位，因?yàn)樵谀承┌姹镜腃中規(guī)定標(biāo)識符前8位有效，當(dāng)兩個標(biāo)識符前8位相同時，則被認(rèn)為是同一個標(biāo)識符。標(biāo)識符是嚴(yán)格區(qū)分大小寫的。例如Imooc和imooc 是兩個不同的標(biāo)識符。標(biāo)識符最好選擇有意義的英文單詞組成做到"見名知意"，不要使用中文。標(biāo)識符不能是C語言的關(guān)鍵字。想了解更多C語言關(guān)鍵字的知識。

七、變量及賦值

變量就是可以變化的量，而每個變量都會有一個名字（標(biāo)識符）。變量占據(jù)內(nèi)存中一定的存儲單元。使用變量之前必須先定義變量，要區(qū)分變量名和變量值是兩個不同的概念。

變量定義的一般形式為：數(shù)據(jù)類型 變量名;

多個類型相同的變量：數(shù)據(jù)類型 變量名, 變量名, 變量名…;

注意:在定義中不允許連續(xù)賦值，如int a=b=c=5;是不合法的。

變量的賦值分為兩種方式:

先聲明再賦值聲明的同時賦值

八、基本數(shù)據(jù)類型

C語言中，數(shù)據(jù)類型可分為：

基本數(shù)據(jù)類型構(gòu)造數(shù)據(jù)類型指針類型空類型四大類

最常用的整型, 實(shí)型與字符型(char,int,float,double):

整型數(shù)據(jù)是指不帶小數(shù)的數(shù)字(int,short int,long int, unsigned int, unsigned short int,unsigned long int):

注：

int short int long int是根據(jù)編譯環(huán)境的不同，所取范圍不同。而其中short int和long int至少是表中所寫范圍, 但是int在表中是以16位編譯環(huán)境寫的取值范圍。另外 c語言int的取值范圍在于他占用的字節(jié)數(shù) ，不同的編譯器，規(guī)定是不一樣。ANSI標(biāo)準(zhǔn)定義int是占2個字節(jié)，TC是按ANSI標(biāo)準(zhǔn)的，它的int是占2個字節(jié)的。但是在VC里，一個int是占4個字節(jié)的。

浮點(diǎn)數(shù)據(jù)是指帶小數(shù)的數(shù)字。

因?yàn)榫鹊牟煌址譃?種(float,double,long double)：

九、格式化輸出語句

格式化輸出語句，也可以說是占位輸出，是將各種類型的數(shù)據(jù)按照格式化后的類型及指定的位置從計算機(jī)上顯示。

其格式為：printf("輸出格式符"，輸出項(xiàng));

當(dāng)輸出語句中包含普通字符時，可以采用以下格式：

printf("普通字符輸出格式符", 輸出項(xiàng));

注意：格式符的個數(shù)要與變量、常量或者表達(dá)式的個數(shù)一一對應(yīng)

十、常量

在程序執(zhí)行過程中，值不發(fā)生改變的量稱為常量。

mtianyan: C語言的常量可以分為直接常量和符號常量。

直接常量也稱為字面量，是可以直接拿來使用，無需說明的量，比如：

整型常量：13、0、-13；實(shí)型常量：13.33、-24.4；字符常量：‘a(chǎn)’、‘M’字符串常量：”I love imooc!”

在C語言中，可以用一個標(biāo)識符來表示一個常量，稱之為符號常量。符號常量在使用之前必須先定義，其一般形式為

#define 標(biāo)識符 常量值

#include#define POCKETMONEY 10    //定義常量及常量值int main(){    // POCKETMONEY = 12;  //小明私自增加零花錢對嗎？    printf("小明今天又得到%d元零花錢\n", POCKETMONEY);    return 0;  }

符號常量不可以被改變。

十一、自動類型轉(zhuǎn)換

數(shù)據(jù)類型存在自動轉(zhuǎn)換的情況. 自動轉(zhuǎn)換發(fā)生在不同數(shù)據(jù)類型運(yùn)算時，在編譯的時候自動完成。

char類型數(shù)據(jù)轉(zhuǎn)換為int類型數(shù)據(jù)遵循ASCII碼中的對應(yīng)值.

注:

十二、強(qiáng)制類型轉(zhuǎn)換

強(qiáng)制類型轉(zhuǎn)換是通過定義類型轉(zhuǎn)換運(yùn)算來實(shí)現(xiàn)的。其一般形式為：

(數(shù)據(jù)類型) (表達(dá)式)

其作用是把表達(dá)式的運(yùn)算結(jié)果強(qiáng)制轉(zhuǎn)換成類型說明符所表示的類型

在使用強(qiáng)制轉(zhuǎn)換時應(yīng)注意以下問題：

數(shù)據(jù)類型和表達(dá)式都必須加括號, 如把(int)(x/2+y)寫成(int)x/2+y則成了把x轉(zhuǎn)換成int型之后再除2再與y相加了。轉(zhuǎn)換后不會改變原數(shù)據(jù)的類型及變量值，只在本次運(yùn)算中臨時性轉(zhuǎn)換。強(qiáng)制轉(zhuǎn)換后的運(yùn)算結(jié)果不遵循四舍五入原則。

十三、運(yùn)算符號

C語言中運(yùn)算符:

1.算術(shù)運(yùn)算符

c語言基本運(yùn)算符:

2.自增與自減運(yùn)算符

自增運(yùn)算符為++，其功能是使變量的值自增1自減運(yùn)算符為--，其功能是使變量值自減1。

它們經(jīng)常使用在循環(huán)中。自增自減運(yùn)算符有以下幾種形式：

3.賦值運(yùn)算符

C語言中賦值運(yùn)算符分為簡單賦值運(yùn)算符和復(fù)合賦值運(yùn)算符

簡單賦值運(yùn)算符=號了，下面講一下復(fù)合賦值運(yùn)算符：

復(fù)合賦值運(yùn)算符就是在簡單賦值符=之前加上其它運(yùn)算符構(gòu)成.

注意：復(fù)合運(yùn)算符中運(yùn)算符和等號之間是不存在空格的。

4.關(guān)系運(yùn)算符

C語言中的關(guān)系運(yùn)算符:

關(guān)系表達(dá)式的值是真和假，在C程序用整數(shù)1和0表示。

注意：>=, <=, ==, !=這種符號之間不能存在空格。

5.邏輯運(yùn)算符

C語言中的邏輯運(yùn)算符:

6.三目運(yùn)算符

C語言中的三目運(yùn)算符：?:，其格式為：

表達(dá)式1 ? 表達(dá)式2 : 表達(dá)式3;  執(zhí)行過程是：

先判斷表達(dá)式1的值是否為真，如果是真的話執(zhí)行表達(dá)式2；如果是假的話執(zhí)行表達(dá)式3。

7.運(yùn)算符大比拼之優(yōu)先級比較

各種運(yùn)算符號的順序:

優(yōu)先級別為1的優(yōu)先級最高，優(yōu)先級別為10的優(yōu)先級別最低。

十四、分支結(jié)構(gòu)

1.簡單if語句

C語言中的分支結(jié)構(gòu)語句中的if條件語句。

簡單if語句的基本結(jié)構(gòu)如下：

if(表達(dá)式){執(zhí)行代碼塊;}

其語義是：如果表達(dá)式的值為真，則執(zhí)行其后的語句，否則不執(zhí)行該語句。

注意：if()后面沒有分號，直接寫{}

2.if-else語句

簡單的if-else語句的基本結(jié)構(gòu):

語義是: 如果表達(dá)式的值為真，則執(zhí)行代碼塊1，否則執(zhí)行代碼塊2。

3.多重if-else語句

C語言中多重if-else語句，其結(jié)構(gòu)如下：

語義是：依次判斷表達(dá)式的值，當(dāng)出現(xiàn)某個值為真時，則執(zhí)行對應(yīng)代碼塊，否則執(zhí)行代碼塊n。

注意：當(dāng)某一條件為真的時候，則不會向下執(zhí)行該分支結(jié)構(gòu)的其他語句。

4.嵌套if-else語句

C語言中嵌套if-else語句。嵌套if-else語句的意思，就是在if-else語句中，再寫if-else語句。其一般形式為：

十五、循環(huán)結(jié)構(gòu)

1.while循環(huán)

反復(fù)不停的執(zhí)行某個動作就是江湖人稱的循環(huán)。

C語言中有三種循環(huán)結(jié)構(gòu),先看一下C語言while循環(huán)的結(jié)構(gòu)

其中表達(dá)式表示循環(huán)條件，執(zhí)行代碼塊為循環(huán)體。

while語句的語義是：計算表達(dá)式的值，當(dāng)值為真(非0)時， 執(zhí)行循環(huán)體代碼塊。

while語句中的表達(dá)式一般是關(guān)系表達(dá)或邏輯表達(dá)式，當(dāng)表達(dá)式的值為假時不執(zhí)行循環(huán)體，反之則循環(huán)體一直執(zhí)行。一定要記著在循環(huán)體中改變循環(huán)變量的值，否則會出現(xiàn)死循環(huán)（無休止的執(zhí)行）。循環(huán)體如果包括有一個以上的語句，則必須用{}括起來，組成復(fù)合語句。

2.do-while循環(huán)

C語言中的do-while循環(huán)，一般形式如下：

do-while循環(huán)語句的語義是:

它先執(zhí)行循環(huán)中的執(zhí)行代碼塊，然后再判斷while中表達(dá)式是否為真，如果為真則繼續(xù)循環(huán)；如果為假，則終止循環(huán)。因此，do-while循環(huán)至少要執(zhí)行一次循環(huán)語句。

注意：mtianyan: 使用do-while結(jié)構(gòu)語句時，while括號后必須有分號。

3.for循環(huán)

c語言中for循環(huán)一般形式：

它的執(zhí)行過程如下：

執(zhí)行表達(dá)式1，對循環(huán)變量做初始化；判斷表達(dá)式2，若其值為真(非0)，則執(zhí)行for循環(huán)體中執(zhí)行代碼塊，然后向下執(zhí)行；若其值為假(0)，則結(jié)束循環(huán);執(zhí)行表達(dá)式3，(i++)等對于循環(huán)變量進(jìn)行操作的語句;執(zhí)行for循環(huán)中執(zhí)行代碼塊后執(zhí)行第二步;第一步初始化只會執(zhí)行一次。循環(huán)結(jié)束，程序繼續(xù)向下執(zhí)行。

注意：for循環(huán)中的兩個分號一定要寫

在for循環(huán)中:

表達(dá)式1是一個或多個賦值語句，它用來控制變量的初始值；表達(dá)式2是一個關(guān)系表達(dá)式，它決定什么時候退出循環(huán)；表達(dá)式3是循環(huán)變量的步進(jìn)值，定義控制循環(huán)變量每循環(huán)一次后按什么方式變化。這三部分之間用分號 ; 分開。

使用for語句應(yīng)該注意：

for循環(huán)中的“表達(dá)式1、2、3”均可不寫為空，但兩個分號(;;)不能缺省。省略“表達(dá)式1（循環(huán)變量賦初值）”，表示不對循環(huán)變量賦初始值。省略“表達(dá)式2(循環(huán)條件)”，不做其它處理，循環(huán)一直執(zhí)行（死循環(huán)）。省略“表達(dá)式3(循環(huán)變量增減量)”，不做其他處理，循環(huán)一直執(zhí)行（死循環(huán)）。表達(dá)式1可以是設(shè)置循環(huán)變量的初值的賦值表達(dá)式，也可以是其他表達(dá)式。表達(dá)式1和表達(dá)式3可以是一個簡單表達(dá)式也可以是多個表達(dá)式以逗號分割。表達(dá)式2一般是關(guān)系表達(dá)式或邏輯表達(dá)式，但也可是數(shù)值表達(dá)式或字符表達(dá)式，只要其值非零，就執(zhí)行循環(huán)體。各表達(dá)式中的變量一定要在for循環(huán)之前定義。

3.三種循環(huán)比較

while, do-while和for三種循環(huán)在具體的使用場合上是有區(qū)別的，如下：

在知道循環(huán)次數(shù)的情況下更適合使用for循環(huán);在不知道循環(huán)次數(shù)的情況下適合使用while或者do-while循環(huán):如果有可能一次都不循環(huán)應(yīng)考慮使用while循環(huán)如果至少循環(huán)一次應(yīng)考慮使用do-while循環(huán)。但是從本質(zhì)上講，while,do-while和for循環(huán)之間是可以相互轉(zhuǎn)換的。

4.多重循環(huán)

多重循環(huán)就是在循環(huán)結(jié)構(gòu)的循環(huán)體中又出現(xiàn)循環(huán)結(jié)構(gòu)。

在實(shí)際開發(fā)中一般最多用到三層重循環(huán)。

因?yàn)檠h(huán)層數(shù)越多，運(yùn)行時間越長，程序越復(fù)雜，所以一般用2-3層多重循環(huán)就可以了。另外不同循環(huán)之間也是可以嵌套的。

多重循環(huán)在執(zhí)行的過程中，外層循環(huán)為父循環(huán)，內(nèi)層循環(huán)為子循環(huán)，

**父循環(huán)一次，子循環(huán)需要全部執(zhí)行完，直到跳出循環(huán)。**父循環(huán)再進(jìn)入下一次，子循環(huán)繼續(xù)執(zhí)行…

十六、結(jié)束語句

1.break語句

那么循環(huán)5次的時候，需要中斷不繼續(xù)訓(xùn)練。在C語言中，可以使用break語句進(jìn)行該操作.

使用break語句時注意以下幾點(diǎn)：

在沒有循環(huán)結(jié)構(gòu)的情況下，break不能用在單獨(dú)的if-else語句中。在多層循環(huán)中，一個break語句只跳出當(dāng)前循環(huán)。

2.continue語句

那么循環(huán)5次的時候，需要中斷后繼續(xù)訓(xùn)練。在C語言中，可以使用continue語句進(jìn)行該操作

continue語句的作用是結(jié)束本次循環(huán)開始執(zhí)行下一次循環(huán)。

break語句與continue語句的區(qū)別是:

break是跳出當(dāng)前整個循環(huán)，continue是結(jié)束本次循環(huán)開始下一次循環(huán)。

十七、局部與全局

C語言中的變量，按作用域范圍可分為兩種，即局部變量和全局變量。局部變量也稱為內(nèi)部變量。局部變量是在函數(shù)內(nèi)作定義說明的。其作用域僅限于函數(shù)內(nèi)， 離開該函數(shù)后再使用這種變量是非法的。在復(fù)合語句中也可定義變量，其作用域只在復(fù)合語句范圍內(nèi)。 全局變量也稱為外部變量，它是在函數(shù)外部定義的變量。它不屬于哪一個函數(shù)，它屬于一個源程序文件。其作用域是整個源程序。

十八、變量存儲類別

mtianyan: C語言根據(jù)變量的生存周期來劃分，可以分為靜態(tài)存儲方式和動態(tài)存儲方式。

靜態(tài)存儲方式：是指在程序運(yùn)行期間分配固定的存儲空間的方式。靜態(tài)存儲區(qū)中存放了在整個程序執(zhí)行過程中都存在的變量，如全局變量。 動態(tài)存儲方式：是指在程序運(yùn)行期間根據(jù)需要進(jìn)行動態(tài)的分配存儲空間的方式。動態(tài)存儲區(qū)中存放的變量是根據(jù)程序運(yùn)行的需要而建立和釋放的，通常包括：函數(shù)形式參數(shù)；自動變量；函數(shù)調(diào)用時的現(xiàn)場保護(hù)和返回地址等。 C語言中存儲類別又分為四類：

自動（auto）、靜態(tài)（static）、寄存器的（register）外部的（extern）。

十九、內(nèi)部函數(shù)與外部函數(shù)

在C語言中不能被其他源文件調(diào)用的函數(shù)稱謂內(nèi)部函數(shù) ，內(nèi)部函數(shù)由static關(guān)鍵字來定義，因此又被稱謂靜態(tài)函數(shù)，形式為： static [數(shù)據(jù)類型] 函數(shù)名（[參數(shù)]） 這里的static是對函數(shù)的作用范圍的一個限定，限定該函數(shù)只能在其所處的源文件中使用，因此在不同文件中出現(xiàn)相同的函數(shù)名稱的內(nèi)部函數(shù)是沒有問題的。 在C語言中能被其他源文件調(diào)用的函數(shù)稱謂外部函數(shù) ，外部函數(shù)由extern關(guān)鍵字來定義，形式為： extern [數(shù)據(jù)類型] 函數(shù)名([參數(shù)]) C語言規(guī)定，在沒有指定函數(shù)的作用范圍時，系統(tǒng)會默認(rèn)認(rèn)為是外部函數(shù)，因此當(dāng)需要定義外部函數(shù)時extern也可以省略。 靜態(tài)變量只賦值一次

二十、數(shù)組初體驗(yàn)

程序中也需要容器，只不過該容器有點(diǎn)特殊，它在程序中是一塊連續(xù)的，大小固定并且里面的數(shù)據(jù)類型一致的內(nèi)存空間，它還有個好聽的名字叫數(shù)組?？梢詫?shù)組理解為大小固定，所放物品為同類的一個購物袋，在該購 物袋中的物品是按一定順序放置的。

1.我們來看一下如何聲明一個數(shù)組：

數(shù)據(jù)類型 數(shù)組名稱[長度];

數(shù)組只聲明也不行啊，看一下數(shù)組是如何初始化的。說到初始化，C語言中的數(shù)組初始化是有三種形式的，分別是：

數(shù)據(jù)類型 數(shù)組名稱[長度n] = {元素1,元素2…元素n};數(shù)據(jù)類型 數(shù)組名稱[] = {元素1,元素2…元素n};數(shù)據(jù)類型 數(shù)組名稱[長度n]; 數(shù)組名稱[0] = 元素1; 數(shù)組名稱[1] = 元素2; 數(shù)組名稱[n-1] = 元素n;

我們將數(shù)據(jù)放到數(shù)組中之后又如何獲取數(shù)組中的元素呢？

獲取數(shù)組元素時： 數(shù)組名稱[元素所對應(yīng)下標(biāo)];

如：初始化一個數(shù)組 int arr[3] = {1,2,3}; 那么arr[0]就是元素1。

注意：

數(shù)組的下標(biāo)均以0開始； 數(shù)組在初始化的時候，數(shù)組內(nèi)元素的個數(shù)不能大于聲明的數(shù)組長度； mtianyan: 如果采用第一種初始化方式，元素個數(shù)小于數(shù)組的長度時，多余的數(shù)組元素初始化為0； 在聲明數(shù)組后沒有進(jìn)行初始化的時候，靜態(tài)（static）和外部（extern）類型的數(shù)組元素初始化元素為0，自動（auto）類型的數(shù)組的元素初始化值不確定。

2.數(shù)組的遍歷

數(shù)組就可以采用循環(huán)的方式將每個元素遍歷出來，而不用人為的每次獲取指定某個位置上的元素，例如我們用for循環(huán)遍歷一個數(shù)組：

注意以下幾點(diǎn)：

最好避免出現(xiàn)數(shù)組越界訪問，循環(huán)變量最好不要超出數(shù)組的長度.C語言的數(shù)組長度一經(jīng)聲明，長度就是固定，無法改變，并且C語言并不提供計算數(shù)組長度的方法。

由于C語言是沒有檢查數(shù)組長度改變或者數(shù)組越界的這個機(jī)制，可能會在編輯器中編譯并通過，但是結(jié)果就不能肯定了，因此還是不要越界或者改變數(shù)組的長度

3.數(shù)組作為函數(shù)參數(shù)

數(shù)組可以由整個數(shù)組當(dāng)作函數(shù)的參數(shù)，也可以由數(shù)組中的某個元素當(dāng)作函數(shù)的參數(shù)：

整個數(shù)組當(dāng)作函數(shù)參數(shù)，即把數(shù)組名稱傳入函數(shù)中，例如：

數(shù)組中的元素當(dāng)作函數(shù)參數(shù)，即把數(shù)組中的參數(shù)傳入函數(shù)中，例如：

數(shù)組作為函數(shù)參數(shù)時注意以下事項(xiàng)：

數(shù)組名作為函數(shù)實(shí)參傳遞時，函數(shù)定義處作為接收參數(shù)的數(shù)組類型形參既可以指定長度也可以不指定長度。數(shù)組元素作為函數(shù)實(shí)參傳遞時，數(shù)組元素類型必須與形參數(shù)據(jù)類型一致。

4.字符串與數(shù)組

C語言中，是沒有辦法直接定義字符串?dāng)?shù)據(jù)類型的，但是我們可以使用數(shù)組來定義我們所要的字符串。一般有以下兩種格式：

char 字符串名稱[長度] = “字符串值”;char 字符串名稱[長度] = {‘字符1’,‘字符2’,…,‘字符n’,’\0’};

注意：

[]中的長度是可以省略不寫的；采用第2種方式的時候最后一個元素必須是’\0’，’\0’表示字符串的結(jié)束標(biāo)志；采用第2種方式的時候在數(shù)組中不能寫中文。在輸出字符串的時候要使用：printf(“%s”,字符數(shù)組名字);或者puts(字符數(shù)組名字);。

5.mtianyan:字符串函數(shù)

常用的字符串函數(shù)如下(strlen,strcmp,strcpy,strcat,atoi):

使用字符串函數(shù)注意以下事項(xiàng)：

strlen()獲取字符串的長度，在字符串長度中是不包括‘\0’而且漢字和字母的長度是不一樣的strcmp()在比較的時候會把字符串先轉(zhuǎn)換成ASCII碼再進(jìn)行比較,返回的結(jié)果為0表示s1和s2的ASCII碼相等,返回結(jié)果為1表示s1比s2的ASCII碼大,返回結(jié)果為-1表示s1比s2的ASCII碼小strcpy()拷貝之后會覆蓋原來字符串且不能對字符串常量進(jìn)行拷貝strcat在使用時s1與s2指的內(nèi)存空間不能重疊，且s1要有足夠的空間來容納要復(fù)制的字符串

6.多維數(shù)組

多維數(shù)組的定義格式是： 數(shù)據(jù)類型 數(shù)組名稱[常量表達(dá)式1][常量表達(dá)式2]…[常量表達(dá)式n];

定義了一個名稱為num，數(shù)據(jù)類型為int的二維數(shù)組。其中第一個[3]表示第一維下標(biāo)的長度，就像購物時分類存放的購物；第二個[3]表示第二維下標(biāo)的長度，就像每個購物袋中的元素。

多維數(shù)組的初始化與一維數(shù)組的初始化類似也是分兩種：

數(shù)據(jù)類型 數(shù)組名稱[常量表達(dá)式1][常量表達(dá)式2]…[常量表達(dá)式n] = {{值1,…,值n},{值1,…,值n},…,{值1,…,值n}};數(shù)據(jù)類型 數(shù)組名稱[常量表達(dá)式1][常量表達(dá)式2]…[常量表達(dá)式n]; 數(shù)組名稱[下標(biāo)1][下標(biāo)2]…[下標(biāo)n] = 值;

多維數(shù)組初始化要注意以下事項(xiàng)：

采用第一種始化時數(shù)組聲明必須指定列的維數(shù)。mtianyan: 因?yàn)橄到y(tǒng)會根據(jù)數(shù)組中元素的總個數(shù)來分配空間，當(dāng)知道元素總個數(shù)以及列的維數(shù)后，會直接計算出行的維數(shù)；采用第二種初始化時數(shù)組聲明必須同時指定行和列的維數(shù)。

二維數(shù)組定義的時候，可以不指定行的數(shù)量，但是必須指定列的數(shù)量

二十一、C語言最核心的指針

說到指針，就不可能脫離開內(nèi)存，學(xué)會指針的人分為兩種，一種是不了解內(nèi)存模型，另外一種則是了解。

不了解的對指針的理解就停留在“指針就是變量的地址”這句話，會比較害怕使用指針，特別是各種高級操作。

而了解內(nèi)存模型的則可以把指針用得爐火純青！

想學(xué)好C語言，很關(guān)鍵就是搞懂內(nèi)存、指針、還有各種編譯鏈接，

1、內(nèi)存本質(zhì)

編程的本質(zhì)其實(shí)就是操控數(shù)據(jù)，數(shù)據(jù)存放在內(nèi)存中。

因此，如果能更好地理解內(nèi)存的模型，以及 C 如何管理內(nèi)存，就能對程序的工作原理洞若觀火，從而使編程能力更上一層樓。

大家真的別認(rèn)為這是空話，我大一整年都不敢用 C 寫上千行的程序也很抗拒寫 C。

因?yàn)橐坏┥锨?，?jīng)常出現(xiàn)各種莫名其妙的內(nèi)存錯誤，一不小心就發(fā)生了 coredump...... 而且還無從排查，分析不出原因。

相比之下，那時候最喜歡 Java，在 Java 里隨便怎么寫都不會發(fā)生類似的異常，頂多偶爾來個 NullPointerException，也是比較好排查的。

直到后來對內(nèi)存和指針有了更加深刻的認(rèn)識，才慢慢會用 C 寫上千行的項(xiàng)目，也很少會再有內(nèi)存問題了。（過于自信

「指針存儲的是變量的內(nèi)存地址」這句話應(yīng)該任何講 C 語言的書都會提到吧。

所以，要想徹底理解指針，首先要理解 C 語言中變量的存儲本質(zhì)，也就是內(nèi)存。

（1）內(nèi)存編址

計算機(jī)的內(nèi)存是一塊用于存儲數(shù)據(jù)的空間，由一系列連續(xù)的存儲單元組成，就像下面這樣，

每一個單元格都表示 1 個 Bit，一個 bit 在 EE 專業(yè)的同學(xué)看來就是高低電位，而在 CS 同學(xué)看來就是 0、1 兩種狀態(tài)。

由于 1 個 bit 只能表示兩個狀態(tài)，所以大佬們規(guī)定 8個 bit 為一組，命名為 byte。

并且將 byte 作為內(nèi)存尋址的最小單元，也就是給每個 byte 一個編號，這個編號就叫內(nèi)存的地址。

這就相當(dāng)于，我們給小區(qū)里的每個單元、每個住戶都分配一個門牌號，在生活中，我們需要保證門牌號唯一，這樣就能通過門牌號很精準(zhǔn)的定位到一家人。

同樣，在計算機(jī)中，我們也要保證給每一個 byte 的編號都是唯一的，這樣才能夠保證每個編號都能訪問到唯一確定的 byte。

（2）內(nèi)存地址空間

上面我們說給內(nèi)存中每個 byte 唯一的編號，那么這個編號的范圍就決定了計算機(jī)可尋址內(nèi)存的范圍。

所有編號連起來就叫做內(nèi)存的地址空間，這和大家平時常說的電腦是 32 位還是 64 位有關(guān)。

早期 Intel 8086、8088 的 CPU 就是只支持 16 位地址空間，寄存器和地址總線都是 16 位，這意味著最多對 2^16 = 64 Kb的內(nèi)存編號尋址。

這點(diǎn)內(nèi)存空間顯然不夠用，后來，80286 在 8086 的基礎(chǔ)上將地址總線和地址寄存器擴(kuò)展到了20 位，也被叫做 A20 地址總線。

當(dāng)時在寫 mini os 的時候，還需要通過 BIOS 中斷去啟動 A20 地址總線的開關(guān)。

但是，現(xiàn)在的計算機(jī)一般都是 32 位起步了，32 位意味著可尋址的內(nèi)存范圍是 2^32 byte = 4GB。

所以，如果你的電腦是 32 位的，那么你裝超過 4G 的內(nèi)存條也是無法充分利用起來的。

好了，這就是內(nèi)存和內(nèi)存編址。

（3）變量的本質(zhì)

有了內(nèi)存，接下來我們需要考慮，int、double 這些變量是如何存儲在 0、1 單元格的。

在 C 語言中我們會這樣定義變量：

int a = 999;char c = "c";

當(dāng)你寫下一個變量定義的時候，實(shí)際上是向內(nèi)存申請了一塊空間來存放你的變量。

我們都知道 int 類型占 4 個字節(jié)，并且在計算機(jī)中數(shù)字都是用補(bǔ)碼（不了解補(bǔ)碼的記得去百度）表示的。

999 換算成補(bǔ)碼就是：0000 0011 1110 0111

這里有 4 個byte，所以需要四個單元格來存儲：

有沒有注意到，我們把高位的字節(jié)放在了低地址的地方，那能不能反過來呢？

當(dāng)然，這就引出了大端和小端。

像上面這種將高位字節(jié)放在內(nèi)存低地址的方式叫做大端，反之，將低位字節(jié)放在內(nèi)存低地址的方式就叫做小端。

上面只說明了 int 型的變量如何存儲在內(nèi)存，而 float、char 等類型實(shí)際上也是一樣的，都需要先轉(zhuǎn)換為補(bǔ)碼。

對于多字節(jié)的變量類型，還需要按照大端或者小端的格式，依次將字節(jié)寫入到內(nèi)存單元。

記住上面這兩張圖，這就是編程語言中所有變量的在內(nèi)存中的樣子，不管是 int、char、指針、數(shù)組、結(jié)構(gòu)體、對象... 都是這樣放在內(nèi)存的。

2、指針是什么啥？

變量放在哪？上面我說，定義一個變量實(shí)際就是向計算機(jī)申請了一塊內(nèi)存來存放。

那如果我們要想知道變量到底放在哪了呢？可以通過運(yùn)算符&來取得變量實(shí)際的地址，這個值就是變量所占內(nèi)存塊的起始地址。

PS: 實(shí)際上這個地址是虛擬地址，并不是真正物理內(nèi)存上的地址

我們可以把這個地址打印出來

printf("%x", &a);

大概會是像這樣的一串?dāng)?shù)字:0x7ffcad3b8f3c

上面說，我們可以通過&符號獲取變量的內(nèi)存地址，那獲取之后如何來表示這是一個地址，而不是一個普通的值呢？

也就是在 C 語言中如何表示地址這個概念呢？

對，就是指針，你可以這樣

int *pa = &a;

pa 中存儲的就是變量 a 的地址，也叫做指向 a 的指針。

在這里我想談幾個看起來有點(diǎn)無聊的話題：

當(dāng)然可以，但是變量名是有局限的。

是變量地址的符號化，變量是為了讓我們編程時更加方便，對人友好，可計算機(jī)可不認(rèn)識什么變量 a，它只知道地址和指令。

所以當(dāng)你去查看 C 語言編譯后的匯編代碼，就會發(fā)現(xiàn)變量名消失了，取而代之的是一串串抽象的地址。

你可以認(rèn)為，編譯器會自動維護(hù)一個映射，將我們程序中的變量名轉(zhuǎn)換為變量所對應(yīng)的地址，然后再對這個地址去進(jìn)行讀寫。

也就是有這樣一個映射表存在，將變量名自動轉(zhuǎn)化為地址：

a  | 0x7ffcad3b8f3cc  | 0x7ffcad3b8f2ch  | 0x7ffcad3b8f4c....

說的好！

可是我還是不知道指針存在的必要性，那么問題來了，看下面代碼:

int func(...) {  ... };int main() { int a; func(...);};

假設(shè)我有一個需求：

你說可以通過&取地址符號，將 a的地址傳遞進(jìn)去：

int func(int address) {  ....};int main() { int a; func(&a);};

這樣在func里就能獲取到 a的地址，進(jìn)行讀寫了。

理論上這是完全沒有問題的，但是問題在于:

編譯器該如何區(qū)分一個 int 里你存的到底是 int 類型的值，還是另外一個變量的地址（即指針）。

這如果完全靠我們編程人員去人腦記憶了，會引入復(fù)雜性，并且無法通過編譯器檢測一些語法錯誤。

而通過int *去定義一個指針變量，會非常明確：這就是另外一個 int 型變量的地址。

編譯器也可以通過類型檢查來排除一些編譯錯誤。

這就是指針存在的必要性。

實(shí)際上任何語言都有這個需求，只不過很多語言為了安全性，給指針戴上了一層枷鎖，將指針包裝成了引用。

可能大家學(xué)習(xí)的時候都是自然而然的接受指針這個東西，但是還是希望這段啰嗦的解釋對你有一定啟發(fā)。

同時，在這里提點(diǎn)小問題：

既然指針的本質(zhì)都是變量的內(nèi)存首地址，即一個 int 類型的整數(shù)。

解引用

上面的問題，就是為了引出指針解引用的。

pa中存儲的是a變量的內(nèi)存地址，那如何通過地址去獲取a的值呢？

這個操作就叫做解引用，在 C 語言中通過運(yùn)算符 *就可以拿到一個指針?biāo)傅刂返膬?nèi)容了。

比如*pa就能獲得a的值。

我們說指針存儲的是變量內(nèi)存的首地址，那編譯器怎么知道該從首地址開始取多少個字節(jié)呢？

這就是指針類型發(fā)揮作用的時候，編譯器會根據(jù)指針的所指元素的類型去判斷應(yīng)該取多少個字節(jié)。

如果是 int 型的指針，那么編譯器就會產(chǎn)生提取四個字節(jié)的指令，char 則只提取一個字節(jié)，以此類推。

下面是指針內(nèi)存示意圖:

pa指針首先是一個變量，它本身也占據(jù)一塊內(nèi)存，這塊內(nèi)存里存放的就是 a變量的首地址。

當(dāng)解引用的時候，就會從這個首地址連續(xù)劃出 4 個 byte，然后按照 int 類型的編碼方式解釋。

別看這個地方很簡單，但卻是深刻理解指針的關(guān)鍵。

舉兩個例子來詳細(xì)說明：

比如：

float f = 1.0;short c = *(short*)&f;

你能解釋清楚上面過程，對于 f變量，在內(nèi)存層面發(fā)生了什么變化嗎？或者 c的值是多少？1 ？

實(shí)際上，從內(nèi)存層面來說，f什么都沒變。

如圖:

假設(shè)這是f在內(nèi)存中的位模式，這個過程實(shí)際上就是把 f的前兩個 byte 取出來然后按照 short 的方式解釋，然后賦值給 c。

詳細(xì)過程如下：

&f取得f 的首地址(short*)&f

上面第二步什么都沒做，這個表達(dá)式只是說 ：

“噢，我認(rèn)為f這個地址放的是一個 short 類型的變量”

最后當(dāng)去解引用的時候*(short*)&f時，編譯器會取出前面兩個字節(jié)，并且按照 short 的編碼方式去解釋，并將解釋出的值賦給 c變量。

這個過程 f的位模式?jīng)]有發(fā)生任何改變，變的只是解釋這些位的方式。

當(dāng)然，這里最后的值肯定不是 1，至于是什么，大家可以去真正算一下。

那反過來，這樣呢？

short c = 1;float f = *(float*)&c;

如圖：

具體過程和上述一樣，但上面肯定不會報錯，這里卻不一定。

為什么？

(float*)&c會讓我們從c的首地址開始取四個字節(jié)，然后按照 float 的編碼方式去解釋。

但是c是 short 類型只占兩個字節(jié)，那肯定會訪問到相鄰后面兩個字節(jié)，這時候就發(fā)生了內(nèi)存訪問越界。

當(dāng)然，如果只是讀，大概率是沒問題的。

但是，有時候需要向這個區(qū)域?qū)懭胄碌闹?，比如?/p>

*(float*)&c = 1.0;

那么就可能發(fā)生 coredump，也就是訪存失敗。

另外，就算是不會 coredump，這種也會破壞這塊內(nèi)存原有的值，因?yàn)楹芸赡苓@是是其它變量的內(nèi)存空間，而我們?nèi)ジ采w了人家的內(nèi)容，肯定會導(dǎo)致隱藏的 bug。

如果你理解了上面這些內(nèi)容，那么使用指針一定會更加的自如。

3、結(jié)構(gòu)體和指針

結(jié)構(gòu)體內(nèi)包含多個成員，這些成員之間在內(nèi)存中是如何存放的呢？

比如：

struct fraction { int num; // 整數(shù)部分 int denom; // 小數(shù)部分};struct fraction fp;fp.num = 10;fp.denom = 2;

這是一個定點(diǎn)小數(shù)結(jié)構(gòu)體，它在內(nèi)存占 8 個字節(jié)（這里不考慮內(nèi)存對齊），兩個成員域是這樣存儲的：

我們把 10 放在了結(jié)構(gòu)體中基地址偏移為 0 的域，2 放在了偏移為 4 的域。

接下來我們做一個這樣的操作：

((fraction*)(&fp.denom))->num = 5; ((fraction*)(&fp.denom))->denom = 12; printf("%d\n", fp.denom); // 輸出多少？

上面這個究竟會輸出多少呢？自己先思考下噢~

接下來我分析下這個過程發(fā)生了什么：

首先，&fp.denom表示取結(jié)構(gòu)體 fp 中 denom 域的首地址，然后以這個地址為起始地址取 8 個字節(jié)，并且將它們看做一個 fraction 結(jié)構(gòu)體。

在這個新結(jié)構(gòu)體中，最上面四個字節(jié)變成了 denom 域，而 fp 的 denom 域相當(dāng)于新結(jié)構(gòu)體的 num 域。

因此：

((fraction*)(&fp.denom))->num = 5

實(shí)際上改變的是 fp.denom，而

((fraction*)(&fp.denom))->denom = 12

則是將最上面四個字節(jié)賦值為 12。

當(dāng)然，往那四字節(jié)內(nèi)存寫入值，結(jié)果是無法預(yù)測的，可能會造成程序崩潰，因?yàn)橐苍S那里恰好存儲著函數(shù)調(diào)用棧幀的關(guān)鍵信息，也可能那里沒有寫入權(quán)限。

大家初學(xué) C 語言的很多 coredump 錯誤都是類似原因造成的。

所以最后輸出的是 5。

為什么要講這種看起來莫名其妙的代碼？

就是為了說明結(jié)構(gòu)體的本質(zhì)其實(shí)就是一堆的變量打包放在一起，而訪問結(jié)構(gòu)體中的域，就是通過結(jié)構(gòu)體的起始地址，也叫基地址，然后加上域的偏移。

其實(shí)，C++、Java 中的對象也是這樣存儲的，無非是他們?yōu)榱藢?shí)現(xiàn)某些面向?qū)ο蟮奶匦?，會在?shù)據(jù)成員以外，添加一些 Head 信息，比如C++ 的虛函數(shù)表。

實(shí)際上，我們是完全可以用 C 語言去模仿的。

這就是為什么一直說 C 語言是基礎(chǔ)，你真正懂了 C 指針和內(nèi)存，對于其它語言你也會很快的理解其對象模型以及內(nèi)存布局。

4、多級指針

說起多級指針這個東西，我以前上學(xué)的時候最多理解到 2 級，再多真的會把我繞暈，經(jīng)常也會寫錯代碼。

你要是給我寫個這個：int ******p能把我搞崩潰，我估計很多同學(xué)現(xiàn)在就是這種情況??

其實(shí)，多級指針也沒那么復(fù)雜，就是指針的指針的指針的指針......非常簡單。

今天就帶大家認(rèn)識一下多級指針的本質(zhì)。

首先，我要說一句話，沒有多級指針這種東西，指針就是指針，多級指針只是為了我們方便表達(dá)而取的邏輯概念。

首先看下生活中的快遞柜：

這種大家都用過吧，每個格子都有一個編號，我們只需要拿到編號，然后就能找到對應(yīng)的格子，取出里面的東西。

這里的格子就是內(nèi)存單元，編號就是地址，格子里放的東西就對應(yīng)存儲在內(nèi)存中的內(nèi)容。

假設(shè)我把一本書，放在了 03 號格子，然后把 03 這個編號告訴你，你就可以根據(jù) 03 去取到里面的書。

那如果我把書放在 05 號格子，然后在 03 號格子只放一個小紙條，上面寫著：「書放在 05 號」。

你會怎么做？

當(dāng)然是打開 03 號格子，然后取出了紙條，根據(jù)上面內(nèi)容去打開 05 號格子得到書。

這里的 03 號格子就叫指針，因?yàn)樗锩娣诺氖侵赶蚱渌褡拥男〖垪l（地址）而不是具體的書。

明白了嗎？

那我如果把書放在 07 號格子，然后在 05 號格子 放一個紙條：「書放在 07號」，同時在03號格子放一個紙條「書放在 05號」

這里的 03 號格子就叫二級指針，05 號格子就叫指針，而 07 號就是我們平常用的變量。

依次，可類推出 N 級指針。

所以你明白了嗎？同樣的一塊內(nèi)存，如果存放的是別的變量的地址，那么就叫指針，存放的是實(shí)際內(nèi)容，就叫變量。

int a;int *pa = &a;int **ppa = &pa;int ***pppa = &ppa;

上面這段代碼，pa就叫一級指針，也就是平時常說的指針，ppa就是二級指針。

內(nèi)存示意圖如下:

不管幾級指針有兩個最核心的東西：

指針本身也是一個變量，需要內(nèi)存去存儲，指針也有自己的地址

指針內(nèi)存存儲的是它所指向變量的地址

這就是我為什么多級指針是邏輯上的概念，實(shí)際上一塊內(nèi)存要么放實(shí)際內(nèi)容，要么放其它變量地址，就這么簡單。

怎么去解讀int **a這種表達(dá)呢？

int ** a可以把它分為兩部分看，即int*和 *a，后面 *a中的*表示 a是一個指針變量，前面的 int*表示指針變量a

只能存放 int*型變量的地址。

對于二級指針甚至多級指針，我們都可以把它拆成兩部分。

首先不管是多少級的指針變量，它首先是一個指針變量，指針變量就是一個*，其余的*表示的是這個指針變量只能存放什么類型變量的地址。

比如int****a表示指針變量 a只能存放int***型變量的地址。

5、指針與數(shù)組

（1）一維數(shù)組

數(shù)組是 C 自帶的基本數(shù)據(jù)結(jié)構(gòu)，徹底理解數(shù)組及其用法是開發(fā)高效應(yīng)用程序的基礎(chǔ)。

數(shù)組和指針表示法緊密關(guān)聯(lián)，在合適的上下文中可以互換。

如下：

int array[10] = {10, 9, 8, 7};printf("%d\n", *array);  //  輸出 10printf("%d\n", array[0]);  // 輸出 10printf("%d\n", array[1]);  // 輸出 9printf("%d\n", *(array+1)); // 輸出 9int *pa = array;printf("%d\n", *pa);  //  輸出 10printf("%d\n", pa[0]);  // 輸出 10printf("%d\n", pa[1]);  // 輸出 9printf("%d\n", *(pa+1)); // 輸出 9

在內(nèi)存中，數(shù)組是一塊連續(xù)的內(nèi)存空間：

第 0 個元素的地址稱為數(shù)組的首地址，數(shù)組名實(shí)際就是指向數(shù)組首地址，當(dāng)我們通過array[1]或者*(array + 1)去訪問數(shù)組元素的時候。

實(shí)際上可以看做 address[offset]，address為起始地址，offset為偏移量，但是注意這里的偏移量offset不是直接和 address相加，而是要乘以數(shù)組類型所占字節(jié)數(shù)，也就是： address + sizeof(int) * offset。

學(xué)過匯編的同學(xué)，一定對這種方式不陌生，這是匯編中尋址方式的一種：基址變址尋址。

看完上面的代碼，很多同學(xué)可能會認(rèn)為指針和數(shù)組完全一致，可以互換，這是完全錯誤的。

盡管數(shù)組名字有時候可以當(dāng)做指針來用，但數(shù)組的名字不是指針。

最典型的地方就是在 sizeof:

printf("%u", sizeof(array));printf("%u", sizeof(pa));

第一個將會輸出 40，因?yàn)?array包含有 10 個int類型的元素，而第二個在 32 位機(jī)器上將會輸出 4，也就是指針的長度。

為什么會這樣呢？

站在編譯器的角度講，變量名、數(shù)組名都是一種符號，它們都是有類型的，它們最終都要和數(shù)據(jù)綁定起來。

變量名用來指代一份數(shù)據(jù)，數(shù)組名用來指代一組數(shù)據(jù)（數(shù)據(jù)集合），它們都是有類型的，以便推斷出所指代的數(shù)據(jù)的長度。

對，數(shù)組也有類型，我們可以將 int、float、char 等理解為基本類型，將數(shù)組理解為由基本類型派生得到的稍微復(fù)雜一些的類型，

數(shù)組的類型由元素的類型和數(shù)組的長度共同構(gòu)成。而 sizeof就是根據(jù)變量的類型來計算長度的，并且計算的過程是在編譯期，而不會在程序運(yùn)行時。

編譯器在編譯過程中會創(chuàng)建一張專門的表格用來保存變量名及其對應(yīng)的數(shù)據(jù)類型、地址、作用域等信息。

sizeof是一個操作符，不是函數(shù)，使用 sizeof時可以從這張表格中查詢到符號的長度。

所以，這里對數(shù)組名使用sizeof可以查詢到數(shù)組實(shí)際的長度。

pa僅僅是一個指向 int 類型的指針，編譯器根本不知道它指向的是一個整數(shù)，還是一堆整數(shù)。

雖然在這里它指向的是一個數(shù)組，但數(shù)組也只是一塊連續(xù)的內(nèi)存，沒有開始和結(jié)束標(biāo)志，也沒有額外的信息來記錄數(shù)組到底多長。

所以對 pa使用 sizeof只能求得的是指針變量本身的長度。

也就是說，編譯器并沒有把 pa和數(shù)組關(guān)聯(lián)起來，pa僅僅是一個指針變量，不管它指向哪里，sizeof求得的永遠(yuǎn)是它本身所占用的字節(jié)數(shù)。

（2）二維數(shù)組

大家不要認(rèn)為二維數(shù)組在內(nèi)存中就是按行、列這樣二維存儲的，實(shí)際上，不管二維、三維數(shù)組... 都是編譯器的語法糖。

存儲上和一維數(shù)組沒有本質(zhì)區(qū)別，舉個例子：

int array[3][3] = {{1, 2，3}, {4, 5，6}，{7, 8, 9}};array[1][1] = 5;

或許你以為在內(nèi)存中 array數(shù)組會像一個二維矩陣:

1  2  34  5  67  8  9

可實(shí)際上它是這樣的：

1  2  3  4  5  6  7  8  9

和一維數(shù)組沒有什么區(qū)別，都是一維線性排列。

當(dāng)我們像 array[1][1]這樣去訪問的時候，編譯器會怎么去計算我們真正所訪問元素的地址呢？

為了更加通用化，假設(shè)數(shù)組定義是這樣的:

int array[n][m]

訪問: array[a][b]

那么被訪問元素地址的計算方式就是: array + (m * a + b)

這個就是二維數(shù)組在內(nèi)存中的本質(zhì)，其實(shí)和一維數(shù)組是一樣的，只是語法糖包裝成一個二維的樣子。

6、 void 指針

想必大家一定看到過 void 的這些用法：

void func();int func1(void);

在這些情況下，void 表達(dá)的意思就是沒有返回值或者參數(shù)為空。

但是對于 void 型指針卻表示通用指針，可以用來存放任何數(shù)據(jù)類型的引用。

下面的例子就 是一個 void 指針：

void *ptr;

void 指針最大的用處就是在 C 語言中實(shí)現(xiàn)泛型編程，因?yàn)槿魏沃羔樁伎梢员毁x給 void 指針，void 指針也可以被轉(zhuǎn)換回原來的指針類型， 并且這個過程指針實(shí)際所指向的地址并不會發(fā)生變化。

比如:

int num;int *pi = # printf("address of pi: %p\n", pi);void* pv = pi;pi = (int*) pv; printf("address of pi: %p\n", pi);

這兩次輸出的值都會是一樣:

平?？赡芎苌贂@樣去轉(zhuǎn)換，但是當(dāng)你用 C 寫大型軟件或者寫一些通用庫的時候，一定離不開 void 指針，這是 C 泛型的基石，比如 std 庫里的 sort 函數(shù)申明是這樣的:

void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));

所有關(guān)于具體元素類型的地方全部用 void 代替。

void 還可以用來實(shí)現(xiàn) C 語言中的多態(tài)，這是一個挺好玩的東西。

不過也有需要注意的，不能對 void 指針解引用

比如：

int num;void *pv = (void*)#*pv = 4; // 錯誤

為什么？

因?yàn)榻庖玫谋举|(zhì)就是編譯器根據(jù)指針?biāo)傅念愋?，然后從指針?biāo)赶虻膬?nèi)存連續(xù)取 N 個字節(jié)，然后將這 N 個字節(jié)按照指針的類型去解釋。

比如 int *型指針，那么這里 N 就是 4，然后按照 int 的編碼方式去解釋數(shù)字。

但是 void，編譯器是不知道它到底指向的是 int、double、或者是一個結(jié)構(gòu)體，所以編譯器沒法對 void 型指針解引用。

關(guān)于指針想寫的內(nèi)容還有很多，這其實(shí)也只算是開了個頭，限于篇幅，以后有機(jī)會補(bǔ)齊以下內(nèi)容:

二維數(shù)組和二維指針

數(shù)組指針和指針數(shù)組

指針運(yùn)算

函數(shù)指針

動態(tài)內(nèi)存分配: malloc 和 free

堆、棧

函數(shù)參數(shù)傳遞方式

內(nèi)存泄露

數(shù)組退化成指針

const 修飾指針