點擊上方“大魚機器人”，選擇“置頂/星標公眾號”福利干貨，第一時間送達！指針對于C來說太重要。然而，想要全面理解指針，除了要對C語言有熟練的掌握外，還要有計算機硬件以及操作系統(tǒng)等方方面面的基本知識。所以本文盡可能的通過一篇文章完全講解指針。

為什么需要指針？

指針解決了一些編程中基本的問題。?指針的使用使得不同區(qū)域的代碼可以輕易的共享內(nèi)存數(shù)據(jù)。當然小伙伴們也可以通過數(shù)據(jù)的復制達到相同的效果，但是這樣往往效率不太好。
因為諸如結(jié)構(gòu)體等大型數(shù)據(jù)，占用的字節(jié)數(shù)多，復制很消耗性能。
但使用指針就可以很好的避免這個問題，因為任何類型的指針占用的字節(jié)數(shù)都是一樣的(根據(jù)平臺不同，有4字節(jié)或者8字節(jié)或者其他可能)。?指針使得一些復雜的鏈接性的數(shù)據(jù)結(jié)構(gòu)的構(gòu)建成為可能，比如鏈表，鏈式二叉樹等等。?有些操作必須使用指針。如操作申請的堆內(nèi)存。
還有：C語言中的一切函數(shù)調(diào)用中，值傳遞都是“按值傳遞”的。
如果我們要在函數(shù)中修改被傳遞過來的對象，就必須通過這個對象的指針來完成。

計算機是如何從內(nèi)存中進行取指的？計算機的總線可以分為3種：數(shù)據(jù)總線，地址總線和控制總線。這里不對控制總線進行描述。數(shù)據(jù)總線用于進行數(shù)據(jù)信息傳送。數(shù)據(jù)總線的位數(shù)一般與CPU的字長一致。一般而言，數(shù)據(jù)總線的位數(shù)跟當前機器int值的長度相等。例如在16位機器上，int的長度是16bit，32位機器則是32bit。這個計算機一條指令最多能夠讀取或者存取的數(shù)據(jù)長度。大于這個值，計算機將進行多次訪問。這也就是我們說的64位機器進行64位數(shù)據(jù)運算的效率比32位要高的原因，因為32位機要進行兩次取指和運行，而64位機卻只需要一次！
地址總線專門用于尋址，CPU通過該地址進行數(shù)據(jù)的訪問，然后把處于該地址處的數(shù)據(jù)通過數(shù)據(jù)總線進行傳送，傳送的長度就是數(shù)據(jù)總線的位數(shù)。地址總線的位數(shù)決定了CPU可直接尋址的內(nèi)存空間大小，比如CPU總線長32位，其最大的直接尋址空間長232KB，也就是4G。這也就是我們常說的32位CPU最大支持的內(nèi)存上限為4G(當然，實際上支持不到這個值，因為一部分尋址空間會被映射到外部的一些IO設備和虛擬內(nèi)存上。現(xiàn)在通過一些新的技術，可以使32位機支持4G以上內(nèi)存，但這個不在這里的討論范圍內(nèi))。一般而言，計算機的地址總線和數(shù)據(jù)總線的寬度是一樣的，我們說32位的CPU，數(shù)據(jù)總線和地址總線的寬度都是32位。計算機訪問某個數(shù)據(jù)的時候，首先要通過地址總線傳送數(shù)據(jù)存儲或者讀取的位置，然后在通過數(shù)據(jù)總線傳送需要存儲或者讀取的數(shù)據(jù)。一般地，int整型的位數(shù)等于數(shù)據(jù)總線的寬度，指針的位數(shù)等于地址總線的寬度。計算機的基本訪問單元學過C語言的人都知道，C語言的基本數(shù)據(jù)類型中，就屬char的位數(shù)最小，是8位。我們可以認為計算機以8位，即1個字節(jié)為基本訪問單元。小于一個字節(jié)的數(shù)據(jù)，必須通過位操作來進行訪問。內(nèi)存訪問方式如圖1所示，計算機在進行數(shù)據(jù)訪問的時候，是以字節(jié)為基本單元進行訪問的，所以可以認為，計算每次都是從第p個字節(jié)開始訪問的。訪問的長度將由編譯器根據(jù)實際類型進行計算，這在后面將會進行講述。內(nèi)存訪問方式想要了解更多，就去翻閱計算機組成原理和編譯原理吧。sizeof關鍵字sizeof關鍵字是編譯器用來計算某些類型的數(shù)據(jù)的長度的，以字節(jié)為基本單位。例如：sizeof(char)=1; sizeof(int)=4;sizeof(Type)的值是在編譯的時候就計算出來了的，可以認為這是一個常量！

指針是什么？我們知道：C語言中的數(shù)組是指一類類型，數(shù)組具體區(qū)分為 ?int 類型數(shù)組，double類型數(shù)組,char數(shù)組 等等。
同樣指針這個概念也泛指一類數(shù)據(jù)類型，int指針類型，double指針類型，char指針類型等等。通常，我們用int類型保存一些整型的數(shù)據(jù)，如 int num = 97 ， 我們也會用char來存儲字符：char ch = 'a'。我們也必須知道：任何程序數(shù)據(jù)載入內(nèi)存后，在內(nèi)存都有他們的地址，這就是指針。
而為了保存一個數(shù)據(jù)在內(nèi)存中的地址，我們就需要指針變量。因此：指針是程序數(shù)據(jù)在內(nèi)存中的地址，而指針變量是用來保存這些地址的變量。在我個人的理解中，可以將指針理解成int整型，只不過它存放的數(shù)據(jù)是內(nèi)存地址，而不是普通數(shù)據(jù)，我們通過這個地址值進行數(shù)據(jù)的訪問，假設它的是p，意思就是該數(shù)據(jù)存放位置為內(nèi)存的第p個字節(jié)。當然，我們不能像對int類型的數(shù)據(jù)那樣進行各種加減乘除操作，這是編譯器不允許的，因為這樣錯是非常危險的！圖2就是對指針的描述，指針的值是數(shù)據(jù)存放地址，因此，我們說，指針指向數(shù)據(jù)的存放位置。

指針的長度我們使用這樣的方式來定義一個指針：Type *p;
我們說p是指向type類型的指針，type可以是任意類型，除了可以是char,short, int, long等基本類型外，還可以是指針類型，例如int *, int **, 或者更多級的指針，也可是是結(jié)構(gòu)體，類或者函數(shù)等。于是，我們說：
int * 是指向int類型的指針；int **，也即(int *) *，是指向int *類型的指針，也就是指向指針的指針；int ***，也即(int **) *，是指向int**類型的指針，也就是指向指針的指針的指針；…我想你應該懂了
struct xxx *，是指向struct xxx類型的指針；
其實，說這么多，只是希望大家在看到指針的時候，不要被int ***這樣的東西嚇到，就像前面說的，指針就是指向某種類型的指針，我們只看最后一個*號，前面的只不過是type類型罷了。
細心一點的人應該發(fā)現(xiàn)了，在“什么是指針”這一小節(jié)當中，已經(jīng)表明了：指針的長度跟CPU的位數(shù)相等，大部分的CPU是32位的，因此我們說，指針的長度是32bit，也就是4個字節(jié)！注意：任意指針的長度都是4個字節(jié)，不管是什么指針！(當然64位機自己去測一下，應該是8個字節(jié)吧。。。)
?于是：Type *p;
izeof(p)的值是4，Type可以是任意類型，char,int, long, struct, class, int **…
以后大家看到什么sizeof(char*), sizeof(int *)，sizeof(xxx *)，不要理會，統(tǒng)統(tǒng)寫4，只要是指針，長度就是4個字節(jié)，絕對不要被type類型迷惑！

為什么程序中的數(shù)據(jù)會有自己的地址？弄清這個問題我們需要從操作系統(tǒng)的角度去認知內(nèi)存。電腦維修師傅眼中的內(nèi)存是這樣的：內(nèi)存在物理上是由一組DRAM芯片組成的。而作為一個程序員，我們不需要了解內(nèi)存的物理結(jié)構(gòu)，操作系統(tǒng)將RAM等硬件和軟件結(jié)合起來，給程序員提供的一種對內(nèi)存使用的抽象。
這種抽象機制使得程序使用的是虛擬存儲器,而不是直接操作和使用真實存在的物理存儲器。
所有的虛擬地址形成的集合就是虛擬地址空間。在程序員眼中的內(nèi)存應該是下面這樣的。也就是說，內(nèi)存是一個很大的，線性的字節(jié)數(shù)組(平坦尋址)。每一個字節(jié)都是固定的大小，由8個二進制位組成。
最關鍵的是，每一個字節(jié)都有一個唯一的編號,編號從0開始，一直到最后一個字節(jié)。
如上圖中，這是一個256M的內(nèi)存，他一共有256x1024x1024 ?= 268435456個字節(jié)，那么它的地址范圍就是 0 ~268435455 ?。由于內(nèi)存中的每一個字節(jié)都有一個唯一的編號。
因此，在程序中使用的變量，常量，甚至數(shù)函數(shù)等數(shù)據(jù)，當他們被載入到內(nèi)存中后，都有自己唯一的一個編號，這個編號就是這個數(shù)據(jù)的地址。
指針就是這樣形成的。下面用代碼說明#include int main(void){ ? ?char ch = 'a'; ? ?int ?num = 97; ? ?printf("ch 的地址:%p",&ch); ? //ch 的地址:0028FF47 ? ?printf("num的地址:%p",&num); ?//num的地址:0028FF40 ? ?return 0;}指針的值實質(zhì)是內(nèi)存單元(即字節(jié))的編號，所以指針單獨從數(shù)值上看，也是整數(shù)，他們一般用16進制表示。
指針的值(虛擬地址值)使用一個機器字的大小來存儲。
也就是說,對于一個機器字為w位的電腦而言,它的虛擬地址空間是0~2w － 1 ,程序最多能訪問2w個字節(jié)。
這就是為什么xp這種32位系統(tǒng)最大支持4GB內(nèi)存的原因了。我們可以大致畫出變量ch和num在內(nèi)存模型中的存儲。(假設 char占1個字節(jié)，int占4字節(jié))

變量和內(nèi)存為了簡單起見，這里就用上面例子中的 ?int num = 97 這個局部變量來分析變量在內(nèi)存中的存儲模型。已知：num的類型是int，占用了4個字節(jié)的內(nèi)存空間，其值是97，地址是0028FF40。我們從以下幾個方面去分析。1、內(nèi)存的數(shù)據(jù)內(nèi)存的數(shù)據(jù)就是變量的值對應的二進制，一切都是二進制。
97的二進制是 : 00000000 00000000 00000000 0110000 , 但使用的小端模式存儲時，低位數(shù)據(jù)存放在低地址，所以圖中畫的時候是倒過來的。2、內(nèi)存數(shù)據(jù)的類型內(nèi)存的數(shù)據(jù)類型決定了這個數(shù)據(jù)占用的字節(jié)數(shù)，以及計算機將如何解釋這些字節(jié)。
num的類型是int，因此將被解釋為 一個整數(shù)。3、內(nèi)存數(shù)據(jù)的名稱內(nèi)存的名稱就是變量名。實質(zhì)上，內(nèi)存數(shù)據(jù)都是以地址來標識的，根本沒有內(nèi)存的名稱這個說法，這只是高級語言提供的抽象機制 ，方便我們操作內(nèi)存數(shù)據(jù)。
而且在C語言中，并不是所有的內(nèi)存數(shù)據(jù)都有名稱，例如使用malloc申請的堆內(nèi)存就沒有。4、內(nèi)存數(shù)據(jù)的地址如果一個類型占用的字節(jié)數(shù)大于1，則其變量的地址就是地址值最小的那個字節(jié)的地址。
因此num的地址是 0028FF40。內(nèi)存的地址用于標識這個內(nèi)存塊。5、內(nèi)存數(shù)據(jù)的生命周期num是main函數(shù)中的局部變量，因此當main函數(shù)被啟動時，它被分配于棧內(nèi)存上，當main執(zhí)行結(jié)束時，消亡。如果一個數(shù)據(jù)一直占用著他的內(nèi)存，那么我們就說他是“活著的”，如果他占用的內(nèi)存被回收了，則這個數(shù)據(jù)就“消亡了”。
C語言中的程序數(shù)據(jù)會按照他們定義的位置，數(shù)據(jù)的種類，修飾的關鍵字等因素，決定他們的生命周期特性。
實質(zhì)上我們程序使用的內(nèi)存會被邏輯上劃分為：棧區(qū)，堆區(qū)，靜態(tài)數(shù)據(jù)區(qū)，方法區(qū)。
不同的區(qū)域的數(shù)據(jù)有不同的生命周期。無論以后計算機硬件如何發(fā)展，內(nèi)存容量都是有限的，因此清楚理解程序中每一個程序數(shù)據(jù)的生命周期是非常重要的。

指針運算N多的面試會考這種東西了：Type *p; p++;
然后問你p的值變化了多少。
其實，也可以認為這是在考編譯器的基本知識。因此p的值并不像表面看到的+1那么簡單，編譯器實際上對p進行的是加sizeof(Type)的操作。看一個一段代碼的測試結(jié)果：
這里注釋掉char一行的原因是因為cout<執(zhí)行結(jié)果：觀察結(jié)果，可以看出，他們的增長結(jié)果分別是：2(sizeof(short)) 4(sizeof(int)) 4(sizeof(long))?????????8(sizeof(long?long))?????????4(sizeof(float))?????????8(sizeof(double))?????????12(sizeof(long?double))
喏，增加的值是不是sizeof(Type)呢？別的什么struct，class之類的，就不驗證你，有興趣的自己去驗證。我們再對這樣的一段代碼進行匯編，查看編譯器是如何進行指針的加法操作的：匯編結(jié)果：注意看注釋部分的結(jié)果，我們看到，piv的值顯示加了4(sizeof(int))，然后又加了16(4*sizeof(int))。

指針變量和指向關系用來保存指針的變量，就是指針變量。
如果指針變量p1保存了變量 num的地址，則就說：p1指向了變量num，也可以說p1指向了num所在的內(nèi)存塊 ，這種指向關系，在圖中一般用 箭頭表示。上圖中，指針變量p1指向了num所在的內(nèi)存塊 ，即從地址0028FF40開始的4個byte 的內(nèi)存塊。

定義指針變量C語言中，定義變量時，在變量名前寫一個 * 星號，這個變量就變成了對應變量類型的指針變量。必要時要加( ) 來避免優(yōu)先級的問題。引申：C語言中，定義變量時，在定義的最前面寫上typedef ，那么這個變量名就成了一種類型，即這個類型的同義詞。int a ; //int類型變量 aint *a ; //int* 變量aint arr[3]; //arr是包含3個int元素的數(shù)組int (* arr )[3]; //arr是一個指向包含3個int元素的數(shù)組的指針變量//-----------------各種類型的指針------------------------------int* p_int; //指向int類型變量的指針 double* p_double; //指向idouble類型變量的指針 struct Student *p_struct; //結(jié)構(gòu)體類型的指針int(*p_func)(int,int); //指向返回類型為int，有2個int形參的函數(shù)的指針 int(*p_arr)[3]; //指向含有3個int元素的數(shù)組的指針 int** p_pointer; //指向 一個整形變量指針的指針

指針的2個重要屬性指針也是一種數(shù)據(jù)，指針變量也是一種變量，因此指針 這種數(shù)據(jù)也符合前面變量和內(nèi)存主題中的特性。
這里要強調(diào)2個屬性：指針的類型，指針的值。int main(void){ ? ?int num = 97; ? ?int *p1 ?= &num; ? ?char* p2 = (char*)(&num); ? ?printf("%d",*p1); ? ?//輸出 ?97 ? ?putchar(*p2); ? ? ? ? ?//輸出 ?a ? ?return 0;}指針的值：很好理解，如上面的num 變量 ，其地址的值就是0028FF40 ，因此 p1的值就是0028FF40。
數(shù)據(jù)的地址用于在內(nèi)存中定位和標識這個數(shù)據(jù)，因為任何2個內(nèi)存不重疊的不同數(shù)據(jù)的地址都是不同的。指針的類型：指針的類型決定了這個指針指向的內(nèi)存的字節(jié)數(shù)并如何解釋這些字節(jié)信息。
一般指針變量的類型要和它指向的數(shù)據(jù)的類型匹配。由于num的地址是0028FF40，因此 p1 和 p2 的值都是0028FF40*p1 ?: ?將從地址0028FF40 開始解析，因為p1是int類型指針，int占4字節(jié)，因此向后連續(xù)取4個字節(jié)，并將這4個字節(jié)的二進制數(shù)據(jù)解析為一個整數(shù) 97。*p2 ?: ?將從地址0028FF40 開始解析，因為p2是char類型指針，char占1字節(jié)，因此向后連續(xù)取1個字節(jié)，并將這1個字節(jié)的二進制數(shù)據(jù)解析為一個字符，即'a'。同樣的地址，因為指針的類型不同，對它指向的內(nèi)存的解釋就不同，得到的就是不同的數(shù)據(jù)。

取地址既然有了指針變量，那就得讓他保存其它變量的地址，使用& 運算符取得一個變量的地址。int add(int a , int b){ ? ?return a + b;}int main(void){ ? ?int num = 97; ? ?float score = 10.00F; ? ?int arr[3] = {1,2,3}; ? ?//----------------------- ? ?int* p_num = &num; ? ?float* p_score = &score; ? ?int (*p_arr)[3] = &arr; ? ? ? ? ? ? ?int (*fp_add)(int ,int ) ?= add; ?//p_add是指向函數(shù)add的函數(shù)指針 ? ?return 0;}特殊的情況，他們并不一定需要使用&取地址：

• 數(shù)組名的值就是這個數(shù)組的第一個元素的地址。
• 函數(shù)名的值就是這個函數(shù)的地址。
• 字符串字面值常量作為右值時，就是這個字符串對應的字符數(shù)組的名稱,也就是這個字符串在內(nèi)存中的地址。

int add(int a , int b){ ? ?return a + b;}int main(void){ ? ?int arr[3] = {1,2,3}; ? ?//----------------------- ? ?int* p_first = arr; ? ?int (*fp_add)(int ,int ) ?= ?add; ? ?const char* msg = "Hello world"; ? ?return 0;}

解地址我們需要一個數(shù)據(jù)的指針變量干什么？
當然使用通過它來操作(讀/寫)它指向的數(shù)據(jù)啦。
對一個指針解地址，就可以取到這個內(nèi)存數(shù)據(jù)，解地址的寫法，就是在指針的前面加一個*號。解指針的實質(zhì)是：從指針指向的內(nèi)存塊中取出這個內(nèi)存數(shù)據(jù)。int main(void){ ? ?int age = 19; ? ?int*p_age = &age; ? ?*p_age ?= 20; ?//通過指針修改指向的內(nèi)存數(shù)據(jù) ? ?printf("age = %d",*p_age); ? //通過指針讀取指向的內(nèi)存數(shù)據(jù) ? ?printf("age = %d",age); ? ?return 0;}

指針之間的賦值指針賦值和int變量賦值一樣，就是將地址的值拷貝給另外一個。
指針之間的賦值是一種淺拷貝，是在多個編程單元之間共享內(nèi)存數(shù)據(jù)的高效的方法。int* p1 ?= & num;int* p3 = p1;//通過指針 p1 、 p3 都可以對內(nèi)存數(shù)據(jù) num 進行讀寫，如果2個函數(shù)分別使用了p1 和p3，那么這2個函數(shù)就共享了數(shù)據(jù)num。

空指針(NULL指針)NULL是C語言標準定義的一個值，這個值其實就是0，只不過為了使得看起來更加具有意義，才定義了這樣的一個宏，中文的意思是空，表明不指向任何東西。你懂得。不過在此不討論空和零的區(qū)別。在C語言中，我們讓指針變量賦值為NULL表示一個空指針，而C語言中，NULL實質(zhì)是((void*)0)，就像前面說的指針可以理解成特殊的int，它總是有值的，p=NULL，其實就是p的值等于0。對于不多數(shù)機器而言，0地址是不能直接訪問的，設置為0，就表示該指針哪里都沒指向。而在C++中，NULL實質(zhì)是0。換種說法：任何程序數(shù)據(jù)都不會存儲在地址為0的內(nèi)存塊中，它是被操作系統(tǒng)預留的內(nèi)存塊。下面代碼摘自 stdlib.h#ifdef __cplusplus ? ? #define NULL ? ?0#else ? ? ? ? #define NULL ? ?((void *)0)#endif當然，就機器內(nèi)部而言，NULL指針的實際值可能與此不同，這種情況下，編譯器將負責零值和內(nèi)部值之間的翻譯轉(zhuǎn)換。NULL指針的概念非常有用，它給了你一種方法，表示某個特定的指針目前并未指向任何東西。例如，一個用于在某個數(shù)組中查找某個特定值的函數(shù)可能返回一個指向查找到的數(shù)組元素的指針。如果沒找到，則返回一個NULL指針。在內(nèi)存的動態(tài)分配上，NULL的意義非同凡響，我們使用它來避免內(nèi)存被多次釋放，造成經(jīng)常性的段錯誤(segmentation fault)。一般，在free或者delete掉動態(tài)分配的內(nèi)存后，都應該立即把指針置空，避免出現(xiàn)所以的懸掛指針，致使出現(xiàn)各種內(nèi)存錯誤！例如：free函數(shù)是不會也不可能把p置空的。像下面這樣的代碼就會出現(xiàn)內(nèi)存段錯誤：因為，第一次free操作之后，p指向的內(nèi)存已經(jīng)釋放了，但是p的值還沒有變化，free函數(shù)改不了這個值，再free一次的時候，p指向的內(nèi)存區(qū)域已經(jīng)被釋放了，這個地址已經(jīng)變成了非法地址，這個操作將導致段錯誤的發(fā)生(此時，p指向的區(qū)域剛好又被分配出去了，但是這種概率非常低，而且對這樣一塊內(nèi)存區(qū)域進行操作是非常危險的！)但是下面這段代碼就不會出現(xiàn)這樣的問題：因為p的值編程了NULL，free函數(shù)檢測到p為NULL，會直接返回，而不會發(fā)生錯誤。這里順便告訴大家一個內(nèi)存釋放的小竅門，可以有效的避免因為忘記對指針進行置空而出現(xiàn)各種內(nèi)存問題。這個方法就是自定義一個內(nèi)存釋放函數(shù)，但是傳入的參數(shù)不知指針，而是指針的地址，在這個函數(shù)里面置空，如下：結(jié)果：
my_free調(diào)用了之后，p的值就變成了0(NULL)，調(diào)用多少次free都不會報錯了！另外一個方式也非常有效，那就是定義FREE宏，在宏里面對他進行置空。例如
執(zhí)行結(jié)果同上面一樣，不會報段錯誤：(關于內(nèi)存的動態(tài)分配，這是個比較復雜的話題，有機會再專門開辟一章給各位講述一下吧，寫個帖子還是很花費時間和精力的，呵呵，寫過的童鞋應該都很清楚，所以順便插一句，轉(zhuǎn)帖可以，請注明出處，畢竟，大家都是本著共享的精神來討論問題的，寫的好壞都沒有向你所要什么，請尊重每個人的勞動成果。)指向空，或者說不指向任何東西。

壞指針指針變量的值是NULL，或者未知的地址值，或者是當前應用程序不可訪問的地址值，這樣的指針就是壞指針。
不能對他們做解指針操作，否則程序會出現(xiàn)運行時錯誤，導致程序意外終止。任何一個指針變量在做解地址操作前，都必須保證它指向的是有效的，可用的內(nèi)存塊，否則就會出錯。
壞指針是造成C語言Bug的最頻繁的原因之一。下面的代碼就是錯誤的示例。void opp(){ ? ? int*p = NULL; ? ? *p = 10; ? ? ?//Oops! 不能對NULL解地址}void foo(){ ? ? int*p; ? ? *p = 10; ? ? ?//Oops! 不能對一個未知的地址解地址}void bar(){ ? ? int*p = (int*)1000; ? ? *p =10; ? ? ?//Oops! ? 不能對一個可能不屬于本程序的內(nèi)存的地址的指針解地址}

void*類型指針?由于void是空類型，因此void*類型的指針只保存了指針的值，而丟失了類型信息，我們不知道他指向的數(shù)據(jù)是什么類型的，只指定這個數(shù)據(jù)在內(nèi)存中的起始地址。
如果想要完整的提取指向的數(shù)據(jù)，程序員就必須對這個指針做出正確的類型轉(zhuǎn)換，然后再解指針。因為，編譯器不允許直接對void*類型的指針做解指針操作。
雖然從字面上看，void的意思是空，但是void指針的意思，可不是空指針的意思，空指針指的是上面所說的NULL指針。void指針實際上的意思是指向任意類型的指針。任意類型的指針都可以直接賦給void指針，而不需要進行強制轉(zhuǎn)換。
例如：Type a, *p=&a;(Type等于char, int, struct, int *…)void *pv;pv=p;就像前面說的，void指針的好處，就在于，任意的指針都可以直接賦值給它，這在某些場合非常有用，因此有些操作對于任意指針都是相同的。void指針最常用于內(nèi)存管理。最典型的，也是大家最熟知的，就是標準庫的free函數(shù)。它的原型如下：void free(void*ptr);free函數(shù)的參數(shù)可以是任意指針，沒有誰見過free參數(shù)里面的指針需要強壯為void*的吧？malloc, calloc,realloc這些函數(shù)的返回值也是void指針，因為內(nèi)存分配，實際上只需要知道分配的大小，然后返回新分配內(nèi)存的地址就可以了，指針的值就是地址，返回的不管是何種指針，其實結(jié)果都是一樣的，因為所有的指針長度其實都是32位的(32位機器)，它的值就是內(nèi)存的地址，指針類型只是給編譯器看的，目的是讓編譯器在編譯的時候能夠正確的設置指針的值(參見指針運算章節(jié))。如果malloc函數(shù)設置成下面這樣的原型，完全沒有問題。char*malloc(size_t sz);
實際上設置成Type*malloc(size_t sz);
也是完全正確的，使用void指針的原因，實際上就像前面說的，void指針意思是任意指針，這樣設計更加嚴謹一些，也更符合我們的直觀理解。如果對前面我說的指針概念理解的童鞋，肯定明白這一點。

結(jié)構(gòu)體和指針結(jié)構(gòu)體指針有特殊的語法：-> 符號如果p是一個結(jié)構(gòu)體指針，則可以使用 p ->【成員】 的方法訪問結(jié)構(gòu)體的成員typedef struct{ ? ?char name[31]; ? ?int age; ? ?float score;}Student;int main(void){ ? ?Student stu = {"Bob" , 19, 98.0}; ? ?Student*ps = &stu; ? ?ps->age = 20; ? ?ps->score = 99.0; ? ?printf("name:%s age:%d",ps->name,ps->age); ? ?return 0;}

數(shù)組和指針1、數(shù)組名作為右值的時候，就是第一個元素的地址。int main(void){ ? ?int arr[3] = {1,2,3}; ? ?int*p_first = arr; ? ?printf("%d",*p_first); ?//1 ? ?return 0;}2、指向數(shù)組元素的指針 支持 遞增 遞減 運算。
(實質(zhì)上所有指針都支持遞增遞減 運算 ，但只有在數(shù)組中使用才是有意義的)int main(void){ ? ?int arr[3] = {1,2,3}; ? ?int*p = arr; ? ?for(;p!=arr+3;p++){ ? ? ? ?printf("%d",*p); ? ?} ? ?return 0;}3、p= p+1 意思是，讓p指向原來指向的內(nèi)存塊的下一個相鄰的相同類型的內(nèi)存塊。同一個數(shù)組中，元素的指針之間可以做減法運算，此時，指針之差等于下標之差。4、p[n] ? ?== *(p+n)p[n][m] ?== *( ?*(p+n)+ m )5、當對數(shù)組名使用sizeof時，返回的是整個數(shù)組占用的內(nèi)存字節(jié)數(shù)。當把數(shù)組名賦值給一個指針后，再對指針使用sizeof運算符，返回的是指針的大小。這就是為什么將一個數(shù)組傳遞給一個函數(shù)時，需要另外用一個參數(shù)傳遞數(shù)組元素個數(shù)的原因了。int main(void){ ? ?int arr[3] = {1,2,3}; ? ?int*p = arr; ? ?printf("sizeof(arr)=%d",sizeof(arr)); ?//sizeof(arr)=12 ? ?printf("sizeof(p)=%d",sizeof(p)); ? //sizeof(p)=4 ? ?return 0;}

函數(shù)和指針函數(shù)的參數(shù)和指針C語言中，實參傳遞給形參，是按值傳遞的，也就是說，函數(shù)中的形參是實參的拷貝份，形參和實參只是在值上面一樣，而不是同一個內(nèi)存數(shù)據(jù)對象。
這就意味著：這種數(shù)據(jù)傳遞是單向的，即從調(diào)用者傳遞給被調(diào)函數(shù)，而被調(diào)函數(shù)無法修改傳遞的參數(shù)達到回傳的效果。void change(int a){ ? a++; ? ? ?//在函數(shù)中改變的只是這個函數(shù)的局部變量a，而隨著函數(shù)執(zhí)行結(jié)束，a被銷毀。age還是原來的age，紋絲不動。}int main(void){ ? ?int age = 19; ? ?change(age); ? ?printf("age = %d",age); ? // age = 19 ? ?return 0;}有時候我們可以使用函數(shù)的返回值來回傳數(shù)據(jù)，在簡單的情況下是可以的。
但是如果返回值有其它用途(例如返回函數(shù)的執(zhí)行狀態(tài)量)，或者要回傳的數(shù)據(jù)不止一個，返回值就解決不了了。傳遞變量的指針可以輕松解決上述問題。void change(int* pa){ ? ?(*pa)++; ? //因為傳遞的是age的地址，因此pa指向內(nèi)存數(shù)據(jù)age。當在函數(shù)中對指針pa解地址時， ? ? ? ? ? ? ? //會直接去內(nèi)存中找到age這個數(shù)據(jù)，然后把它增1。}int main(void){ ? ?int age = 19; ? ?change(&age); ? ?printf("age = %d",age); ? // age = 20 ? ?return 0;}再來一個老生常談的，用函數(shù)交換2個變量的值的例子：#includevoid swap_bad(int a,int b);void swap_ok(int*pa,int*pb);int main(){ ? ?int a = 5; ? ?int b = 3; ? ?swap_bad(a,b); ? ? ? //Can`t swap; ? ?swap_ok(&a,&b); ? ? ?//OK ? ?return 0;}//錯誤的寫法void swap_bad(int a,int b){ ? ?int t; ? ?t=a; ? ?a=b; ? ?b=t;}//正確的寫法：通過指針void swap_ok(int*pa,int*pb){ ? ?int t; ? ?t=*pa; ? ?*pa=*pb; ? ?*pb=t;}有的時候，我們通過指針傳遞數(shù)據(jù)給函數(shù)不是為了在函數(shù)中改變他指向的對象。
相反，我們防止這個目標數(shù)據(jù)被改變。傳遞指針只是為了避免拷貝大型數(shù)據(jù)。考慮一個結(jié)構(gòu)體類型Student。我們通過show函數(shù)輸出Student變量的數(shù)據(jù)。typedef struct{ ? ?char name[31]; ? ?int age; ? ?float score;}Student;//打印Student變量信息void show(const Student * ps){ ? ?printf("name:%s , age:%d , score:%.2f",ps->name,ps->age,ps->score); ? }我們只是在show函數(shù)中取讀Student變量的信息，而不會去修改它，為了防止意外修改，我們使用了常量指針去約束。
另外我們?yōu)槭裁匆褂弥羔樁皇侵苯觽鬟fStudent變量呢？從定義的結(jié)構(gòu)看出，Student變量的大小至少是39個字節(jié)，那么通過函數(shù)直接傳遞變量，實參賦值數(shù)據(jù)給形參需要拷貝至少39個字節(jié)的數(shù)據(jù)，極不高效。
而傳遞變量的指針卻快很多，因為在同一個平臺下，無論什么類型的指針大小都是固定的：X86指針4字節(jié)，X64指針8字節(jié)，遠遠比一個Student結(jié)構(gòu)體變量小。函數(shù)的指針跟普通的變量一樣，每一個函數(shù)都是有其地址的，我們通過跳轉(zhuǎn)到這個地址執(zhí)行代碼來進行函數(shù)調(diào)用，只是，跟取普通數(shù)據(jù)不同的在于，函數(shù)有參數(shù)和返回值，在進行函數(shù)調(diào)用的時候，首先需要將參數(shù)壓入棧中，調(diào)用完成后又需要將參數(shù)壓入棧中。既然函數(shù)也是通過地址來進行訪問的，那它也可以使用指針來指向，事實上，每一個函數(shù)名都是一個指針，不過它是指針常量和指針常量，它的值是不能改的，指向的值也不能改。(關于常量指針和指針常量什么的，有時間在專門開辟一章來說明const這個東東吧，也是很有講頭的一個東東。。。)函數(shù)指針一般用來干什么呢？函數(shù)指針最常用的場合就是回調(diào)函數(shù)。回調(diào)函數(shù)，顧名思義，就是某個函數(shù)會在適當?shù)臅r候被別人調(diào)用。當期望你調(diào)用的函數(shù)能夠使用你的某些方式去操作的時候，回調(diào)函數(shù)就很有用，比如，你期望某個排序函數(shù)在比較的時候，能夠使用你定義的比較方法去比較。有過較深入的C編程經(jīng)驗的人應該都接觸過。C的標準庫中就有使用，例如在strlib.h頭文件的qsort函數(shù)，它的原型為：void qsort(void*__base, size_t __nmemb, size_t __size, int(*_compar)(const void *, const void*));其中int(*_compar)(const void *, const void *)就是回調(diào)函數(shù)，這個函數(shù)用于qsort函數(shù)用于數(shù)據(jù)的比較。下面，我會舉一個例子，來描述qsort函數(shù)的工作原理。一般，我們使用下面這樣的方式來定義函數(shù)指針：typedef int(*compare)(const void *x, const void *y);這個時候，compare就是參數(shù)為const void *, const void *類型，返回值是int類型的函數(shù)。例如：用typedef來定義的好處，就是可以使用一個簡短的名稱來表示一種類型，而不需要總是使用很長的代碼來，這樣不僅使得代碼更加簡潔易讀，更是避免了代碼敲寫容易出錯的問題。強烈推薦各位在定義結(jié)構(gòu)體，指針(尤其是函數(shù)指針)等比較復雜的結(jié)構(gòu)時，使用typedef來定義。每一個函數(shù)本身也是一種程序數(shù)據(jù)，一個函數(shù)包含了多條執(zhí)行語句，它被編譯后，實質(zhì)上是多條機器指令的合集。
在程序載入到內(nèi)存后，函數(shù)的機器指令存放在一個特定的邏輯區(qū)域：代碼區(qū)。
既然是存放在內(nèi)存中，那么函數(shù)也是有自己的指針的。C語言中，函數(shù)名作為右值時，就是這個函數(shù)的指針。void echo(const char *msg){ ? ?printf("%s",msg);}int main(void){ ? ?void(*p)(const char*) = echo; ? //函數(shù)指針變量指向echo這個函數(shù) ? ?p("Hello "); ? ? ?//通過函數(shù)的指針p調(diào)用函數(shù)，等價于echo("Hello ") ? ?echo("World"); ? ?return 0;}const和指針const到底修飾誰？誰才是不變的？如果const 后面是一個類型，則跳過最近的原子類型，修飾后面的數(shù)據(jù)。
(原子類型是不可再分割的類型，如int, short , char，以及typedef包裝后的類型)如果const后面就是一個數(shù)據(jù)，則直接修飾這個數(shù)據(jù)。int main(){ ? ?int a = 1; ? ?int const *p1 = &a; ? ? ? ?//const后面是*p1，實質(zhì)是數(shù)據(jù)a，則修飾*p1，通過p1不能修改a的值 ? const int*p2 = ?&a; ? ? ? ?//const后面是int類型，則跳過int ，修飾*p2， 效果同上 ? int* const p3 = NULL; ? ? ?//const后面是數(shù)據(jù)p3。也就是指針p3本身是const . ? const int* const p4 = &a; ?// 通過p4不能改變a 的值，同時p4本身也是 const ? int const* const p5 = &a; ?//效果同上 ? return 0;}typedef int* pint_t; ?//將 int* 類型 包裝為 pint_t,則pint_t 現(xiàn)在是一個完整的原子類型int main(){ ? int a ?= 1; ? const pint_t p1 = &a; ?//同樣，const跳過類型pint_t，修飾p1，指針p1本身是const ? pint_t const p2 = &a; ?//const 直接修飾p，同上 ? return 0;}深拷貝和淺拷貝如果2個程序單元(例如2個函數(shù))是通過拷貝他們所共享的數(shù)據(jù)的指針來工作的，這就是淺拷貝，因為真正要訪問的數(shù)據(jù)并沒有被拷貝。
如果被訪問的數(shù)據(jù)被拷貝了，在每個單元中都有自己的一份，對目標數(shù)據(jù)的操作相互不受影響，則叫做深拷貝。附加知識指針和引用這個2個名詞的區(qū)別。他們本質(zhì)上來說是同樣的東西。
指針常用在C語言中，而引用，則用于諸如Java，C#等 在語言層面封裝了對指針的直接操作的編程語言中。大端模式和小端模式1) Little-Endian就是低位字節(jié)排放在內(nèi)存的低地址端，高位字節(jié)排放在內(nèi)存的高地址端。個人PC常用，Intel X86處理器是小端模式。2) B i g-Endian就是高位字節(jié)排放在內(nèi)存的低地址端，低位字節(jié)排放在內(nèi)存的高地址端。采用大端方式進行數(shù)據(jù)存放符合人類的正常思維，而采用小端方式進行數(shù)據(jù)存放利于計算機處理。
有些機器同時支持大端和小端模式,通過配置來設定實際的端模式。假如 short類型占用2個字節(jié)，且存儲的地址為0x30。short a = 1;如下圖：//測試機器使用的是否為小端模式。是，則返回true，否則返回false
//這個方法判別的依據(jù)就是：C語言中一個對象的地址就是這個對象占用的字節(jié)中，地址值最小的那個字節(jié)的地址。bool isSmallIndain(){ ? ? ?unsigned int val = 'A'; ? ? unsigned char* p = (unsigned char*)&val; ?//C/C++：對于多字節(jié)數(shù)據(jù)，取地址是取的數(shù)據(jù)對象的第一個字節(jié)的地址，也就是數(shù)據(jù)的低地址 ? ? ?return *p == 'A';}-END-|?整理文章為傳播相關技術，版權歸原作者所有?||?如有侵權，請聯(lián)系刪除?|

往期好文合集

搞懂C語言指針，看這篇就夠了！聊聊指針「2020年電賽」電源題詳細技術方案，立即收藏！

??最 后???

若覺得文章不錯，轉(zhuǎn)發(fā)分享，也是我們繼續(xù)更新的動力。5T資源大放送！包括但不限于：C/C++，Linux，Python，Java，PHP，人工智能，PCB、FPGA、DSP、labview、單片機、等等！在公眾號內(nèi)回復「更多資源」，即可免費獲取，期待你的關注~ 創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結(jié)

以上是生活随笔為你收集整理的c语言贪吃蛇最简单代码_C语言指针，这可能是史上最干最全的讲解啦（附代码）！！！...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。