Thinking in C -- C指針

忘記悲傷最好的辦法可能就是讓本身有事作吧。 由於工做須要，不少好朋友都在從新補最基礎也是最重要的C語言。人常說沒有學好指針就等於沒有學過C，在學校時可能老師只是爲了應付考試，而一直在講那些死板的語法。但對這個C語言（也是任何編程思想）的精髓沒有重視。
     確實，在幾年的編程過程當中，感受對指針的精通可讓咱們對任何語言都舉一反三了。語言只是方便咱們表達本身思想的助記符，真正的程序在內存中是如何運行的？理解指針可讓你更清楚的知道。
    最近在網上看了一些講解指針的文章，從這些文章中將本身對指針的瞭解加以整理，我認爲基本上若是能夠真正理解下面這些，那麼你能夠對別人說你對C的思想已經精通了。徹底精通一門語言固然還要知道它經常使用的庫函數，固然那些就要你本身多編，多記了。

/*--------------------------------概念------------------------------------------*/

指針是一個特殊的變量，它裏面存儲的數值被解釋成爲內存裏的一個地址。

要搞清一個指針須要搞清指針的四方面的內容：

[1]指針的類型,

[2]指針所指向的類型，

[3]指針的值或者叫指針所指向的內存區，

[4]還有指針自己所佔據的內存區。 --sizeof(指針變量名) 通常32位機都爲4;

指針的類型(即指針自己的類型)和指針所指向的類型是兩個概念。當你對C愈來愈熟悉時，你會發現，把與指針攪和在一塊兒的"類型"這個概念分紅"指針的類型"和"指針所指向的類型"兩個概念，是精通指針的關鍵點之一。

[1]指針的類型: (指針自己在內存中的樣子,類型)

　　從語法的角度看，你只要把指針聲明語句裏的指針名字去掉，剩下的部分就是這個指針的類型。這是指針自己所具備的類型。

       [用途]在指針的賦值運算時,知道了指針的類型就能夠來定右值得類型了;

      

[2]指針所指向的類型:(指針所指向的內存塊裏應存的是什麼樣子(類型)的東東)

       當你經過指針來訪問指針所指向的內存區時，指針所指向的類型決定了編譯器將把那片內存區裏的內容當作什麼來看待。

　　從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符*去掉，剩下的就是指針所指向的類型。

[3]指針的值或者叫指針所指向的內存區:

       指針所指向的內存區就是從指針的值所表明的那個內存地址開始，長度爲sizeof(指針所指向的類型)的一片內存區。

      

[小結]    

       例:

       int(*ptr)[3];

       //指針的類型是int(*)[3] -- 一個數組指針,它至關於行指針,它所指的都是一個int()[3]--一維數組;

       //指針所指向的的類型是int()[3] -- 這個就是這個指針所指的內存中應存的東西的類型,及一維數組;

       指針所指向的內存區和指針所指向的類型是兩個徹底不一樣的概念。在上面，指針所指向的類型已經有了(聲明瞭)，但因爲指針還未初始化(未定義,未初始化)，因此它所指向的內存區是不存在的，或者說是無心義的。

　　之後，每遇到一個指針，都應該問問：這個指針的類型是什麼？指針指的類型是什麼？該指針指向了哪裏？

注意不知道指針指向哪裏就開始用是很危險及隱蔽的錯誤!!!

-------------------------------------實例分析----------------------------------

例四：

　　一、chara[20];

　　二、int*ptr=a;

　　...

　　...

　　三、ptr+=5;

　　在這個例子中，ptr被加上了5，編譯器是這樣處理的：將指針ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。因爲地址的單位是字節，故如今的ptr所指向的地址比起加5後的ptr所指向的地址來講，向高地址方向移動了20個字節。在這個例子中，沒加5前的ptr指向數組a的第0號單元開始的四個字節，加5後，ptr已經指向了數組a的合法範圍以外了。雖然這種狀況在應用上會出問題，但在語法上倒是能夠的。這也體現出了指針的靈活性。

[說明]

       [1]由於指針的類型是int *,因此在第2步時不要誤認爲指針的類型是a的類型(char);

       [2]指針如今指向長度爲20字節的數組a的首地址了,在第三句時ptr所指的地方正好越出了數組的邊界

              -- a[19] or (ptr+19)了.

             

--------------------------數組和指針的關係---------------------------------

　　數組的數組名其實能夠看做一個指針。看下例：

　　例八：

intarray[10]={0,1,2,3,4,5,6,7,8,9},value;

...

...

value=array[0];//也可寫成：value=*array;

value=array[3];//也可寫成：value=*(array+3);

value=array[4];//也可寫成：value=*(array+4);

上例中，通常而言數組名array表明數組自己，類型是int[10]，但若是把array看作指針的話，它指向數組的第0個單元，類型是int*，所指向的類型是數組單元的類型即int。所以*array等於0就一點也不奇怪了。同理，array+3是一個指向數組第3個單元的指針，因此*(array+3)等於3。其它依此類推。

　　例九：

char*str[3]={

　"Hello,thisisasample!",

　"Hi,goodmorning.",

　"Helloworld"

};

chars[80]；

strcpy(s,str[0]);//也可寫成strcpy(s,*str);

strcpy(s,str[1]);//也可寫成strcpy(s,*(str+1));

strcpy(s,str[2]);//也可寫成strcpy(s,*(str+2));

上例中，str是一個三單元的數組，該數組的每一個單元都是一個指針，這些指針各指向一個字符串。把指針數組名str看成一個指針的話，它指向數組的第0號單元，它的類型是char**，它指向的類型是char*。

*str也是一個指針，它的類型是char*，它所指向的類型是char，它指向的地址是字符串"Hello,thisisasample!"的第一個字符的地址，即'H'的地址。 str+1也是一個指針，它指向數組的第1號單元，它的類型是char**，它指向的類型是char*。

　　*(str+1)也是一個指針，它的類型是char*，它所指向的類型是char，它指向 "Hi,goodmorning."的第一個字符'H'，等等。

　　下面總結一下數組的數組名的問題。聲明瞭一個數組TYPE  array[n]，則數組名稱array就有了兩重含義：第一，它表明整個數組，它的類型是TYPE[n]；第二 ，它是一個指針，該指針的類型是TYPE*，該指針指向的類型是TYPE，也就是數組單元的類型，該指針指向的內存區就是數組第0號單元，該指針本身佔有單獨的內存區，注意它和數組第0號單元佔據的內存區是不一樣的。該指針的值是不能修改的，即相似array++的表達式是錯誤的。

　　在不一樣的表達式中數組名array能夠扮演不一樣的角色。

　　在表達式sizeof(array)中，數組名array表明數組自己，故這時sizeof函數測出的是整個數組的大小。

在表達式*array中，array扮演的是指針，所以這個表達式的結果就是數組第0號單元的值。sizeof(*array)測出的是數組單元的大小。

　　表達式array+n（其中n=0，1，2，....。）中，array扮演的是指針，故array+n的結果是一個指針，它的類型是TYPE*，它指向的類型是TYPE，它指向數組第n號單元。故sizeof(array+n)測出的是指針類型的大小。

例十

intarray[10];

int(*ptr)[10];

ptr=&array;：

上例中ptr是一個指針，它的類型是int(*)[10]，他指向的類型是int[10] ，咱們用整個數組的首地址來初始化它。在語句ptr=&array中，array表明數組自己。

　　本節中提到了函數sizeof()，那麼我來問一問，sizeof(指針名稱)測出的到底是指針自身類型的大小呢仍是指針所指向的類型的大小？答案是前者。例如：

int(*ptr)[10];

　　則在32位程序中，有：

sizeof(int(*)[10])==4

sizeof(int[10])==40

sizeof(ptr)==4

實際上，sizeof(對象)測出的都是對象自身的類型的大小，而不是別的什麼類型的大小。

[Note]

數組名能夠看做是指針，可是數組名不是指針。也不會有本身的內存區

&a

&a[0]

是最好的說明

--------------------指針和結構類型的關係-------------------------------------------

能夠聲明一個指向結構類型對象的指針。

　　例十一：

structMyStruct

{

　int a;

　int b;

　int c;

}

MyStruct ss={20,30,40};

//聲明告終構對象ss，並把ss的三個成員初始化爲20，30和40。

MyStruct*ptr=&ss;

//聲明瞭一個指向結構對象ss的指針。它的類型是MyStruct*,它指向的類型是MyStruct。

int*pstr=(int*)&ss;

//聲明瞭一個指向結構對象ss的指針。可是它的類型和它指向的類型和ptr是不一樣的。

　　請問怎樣經過指針ptr來訪問ss的三個成員變量？

　　答案：

ptr->a;

ptr->b;

ptr->c;

　　又請問怎樣經過指針pstr來訪問ss的三個成員變量？

　　答案：

*pstr；//訪問了ss的成員a。

*(pstr+1);//訪問了ss的成員b。

*(pstr+2)//訪問了ss的成員c。

　　雖然我在個人MSVC++6.0上調式過上述代碼，可是要知道，這樣使用pstr來訪問結構成員是不正規的，爲了說明爲何不正規，讓咱們看看怎樣經過指針來訪問數組的各個單元：

　　例十二：

int array[3]={35,56,37};

int*pa=array;

　　經過指針pa訪問數組array的三個單元的方法是：

*pa;//訪問了第0號單元

*(pa+1);//訪問了第1號單元

*(pa+2);//訪問了第2號單元

從格式上看卻是與經過指針訪問結構成員的不正規方法的格式同樣。

　　全部的C/C++編譯器在排列數組的單元時，老是把各個數組單元存放在連續的存儲區裏，單元和單元之間沒有空隙。但在存放結構對象的各個成員時，在某種編譯環境下，可能會須要字對齊或雙字對齊或者是別的什麼對齊，須要在相鄰兩個成員之間加若干個"填充字節"，這就致使各個成員之間可能會有若干個字節的空隙。

　　因此，在例十二中，即便*pstr訪問到告終構對象ss的第一個成員變量a，也不能保證*(pstr+1)就必定能訪問到結構成員b。由於成員a和成員b之間可能會有若干填充字節，說不定*(pstr+1)就正好訪問到了這些填充字節呢。這也證實了指針的靈活性。要是你的目的就是想看看各個結構成員之間到底有沒有填充字節，嘿，這卻是個不錯的方法。

過指針訪問結構成員的正確方法應該是象例十二中使用指針ptr的方法。

      

---------------------------指針類型轉換--------------------------------------

沒有隱式轉化這一說，都要進行強轉；

若是有一個指針p，咱們須要把它的類型和所指向的類型改成TYEP*， 那麼語法格式是：

　　(TYPE*)p；

　　這樣強制類型轉換的結果是一個新指針，該新指針的類型是TYPE*，它指向的類型是TYPE，它指向的地址就是原指針指向的地址。而原來的指針p的一切屬性都沒有被修改。

　　一個函數若是使用了指針做爲形參，那麼在函數調用語句的實參和形參的結合過程當中，也會發生指針類型的轉換。

　　例十五：

void fun(char*);

int a=125, b;

fun((char*)&a);

...

...

void fun(char *s)

{

char c;

c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;

c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;

}

注意這是一個32位程序，故int類型佔了四個字節，char類型佔一個字節。函數fun的做用是把一個整數的四個字節的順序來個顛倒。注意到了嗎？在函數調用語句中，實參&a的結果是一個指針，它的類型是int*，它指向的類型是int。形參這個指針的類型是char*，它指向的類型是char。這樣，在實參和形參的結合過程當中，咱們必須進行一次從int*類型到char*類型的轉換。結合這個例子，咱們能夠這樣來想象編譯器進行轉換的過程：編譯器先構造一個臨時指針char*temp， 而後執行temp=(char*)&a，最後再把temp的值傳遞給s。因此最後的結果是：s的類型是char*,它指向的類型是char，它指向的地址就是a的首地址。

[Note] 編譯器會自動用形參來轉換指針的類型。

 

想一想能不能反過來，把指針指向的地址即指針的值看成一個整數取出來。徹底能夠。下面的例子演示了把一個指針的值看成一個整數取出來，而後再把這個整數看成一個地址賦給一個指針：

　　例十六：

int a=123, b;

int *ptr= &a;

char *str;

b=(int)ptr;//把指針ptr的值看成一個整數取出來。

str=(char*)b;//把這個整數的值看成一個地址賦給指針str。

如今咱們已經知道了，能夠把指針的值看成一個整數取出來，也能夠把一個整數值看成地址賦給一個指針。

-------------------------------------------指針的安全問題（重點）-------------------------------------

 

　　例十七：

char s='a';                          

int *ptr;

ptr=(int*)&s;

*ptr=1298；

指針ptr是一個int*類型的指針，它指向的類型是int。它指向的地址就是s的首地址。在32位程序中，s佔一個字節，int類型佔四個字節。最後一條語句不但改變了s所佔的一個字節，還把和s相臨的高地址方向的三個字節也改變了。這三個字節是幹什麼的？只有編譯程序知道，而寫程序的人是不太可能知道的。也許這三個字節裏存儲了很是重要的數據，也許這三個字節里正好是程序的一條代碼，而因爲你對指針的馬虎應用，這三個字節的值被改變了！這會形成崩潰性的錯誤。

 

　　讓咱們再來看一例：

　　例十八：

　　一、char a;

　　二、int *ptr= &a;

　　...

　　...

　　三、ptr++;

　　四、*ptr=115;

　　該例子徹底能夠經過編譯，並能執行。可是看到沒有？第3句對指針ptr進行自加1運算後，ptr指向了和×××變量a相鄰的高地址方向的一塊存儲區。這塊存儲區裏是什麼？咱們不知道。有可能它是一個很是重要的數據，甚至多是一條代碼。而第4句居然往這片存儲區裏寫入一個數據！這是嚴重的錯誤。因此在使用指針時，程序員內心必須很是清楚：個人指針究竟指向了哪裏。在用指針訪問數組的時候，也要注意不要超出數組的低端和高端界限，不然也會形成相似的錯誤。

在指針的強制類型轉換：ptr1=(TYPE*)ptr2中，若是sizeof(ptr2的類型)大於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的存儲區時是安全的。若是sizeof(ptr2的類型)小於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的存儲區時是不

 

安全的。至於爲何，結合例十七來想想，應該會明白的。

本文來自CSDN博客，轉載請標明出處： file:///G:/Documents%20and%20Settings/HK/桌面/Thinking%20in%20C%20--%20C指針%20-%20蟲子專欄%20-%20CSDN博客.mht