忘記悲傷最好的辦法可能就是讓自己有事做吧。 因爲工作需要，很多好朋友都在重新補最基礎也是最重要的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] -- 這個就是這個指針所指的內存中應存的東西的類型,及一維數組;
指針所指向的內存區和指針所指向的類型是兩個完全不同的概念。在上面，指針所指向的類型已經有了(聲明瞭)，但由於指針還未初始化(未定義,未初始化)，所以它所指向的內存區是不存在的，或者說是無意義的。
以後，每遇到一個指針，都應該問問：這個指針的類型是什麼？指針指的類型是什麼？該指針指向了哪裏？
注意不知道指針指向哪裏就開始用是很危險及隱蔽的錯誤!!!
-------------------------------------實例分析----------------------------------
例四：
1、chara[20];
2、int*ptr=a;
...
...
3、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相臨的高地址方向的三個字節也改變了。這三個字節是幹什麼的？只有編譯程序知道，而寫程序的人是不太可能知道的。也許這三個字節裏存儲了非常重要的數據，也許這三個字節里正好是程序的一條代碼，而由於你對指針的馬虎應用，這三個字節的值被改變了！這會造成崩潰性的錯誤。
讓我們再來看一例：
例十八：
1、char a;
2、int *ptr= &a;
...
...
3、ptr++;
4、*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