第一章 指針的概念
指針是一個特殊的變量，它裡面存儲的數值被解釋成為內存裡的一個地址。
要搞清一個指針需要搞清指針的四方面的內容：指針的類型，指針所指向的
類型，指針的值或者叫指針所指向的內存區，還有指針本身所占據的內存區。讓
我們分別說明。
先聲明幾個指針放著做例子：
例一：
(1)int *ptr;
(2)char *ptr;
(3)int **ptr;
(4)int (*ptr)[3];
(5)int *(*ptr)[4];
如果看不懂後幾個例子的話，請參閱我前段時間貼出的文?lt;<如何理解c和c
++的復雜類型聲明>>。
1.指針的類型。
從語法的角度看，你只要把指針聲明語句裡的指針名字去掉，剩下的部分就
是這個指針的類型。這是指針本身所具有的類型。讓我們看看例一中各個指針的
類型：
(1)int *ptr; //指針的類型是int *
(2)char *ptr; //指針的類型是char *
(3)int **ptr; //指針的類型是 int **
(4)int (*ptr)[3]; //指針的類型是 int(*)[3]
(5)int *(*ptr)[4]; //指針的類型是 int *(*)[4]
怎麼樣？找出指針的類型的方法是不是很簡單？
2.指針所指向的類型。
當你通過指針來訪問指針所指向的內存區時，指針所指向的類型決定了編譯
器將把那片內存區裡的內容當做什麼來看待。
從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符
*去掉，剩下的就是指針所指向的類型。例如：
(1)int *ptr; //指針所指向的類型是int
(2)char *ptr; //指針所指向的的類型是char
(3)int **ptr; //指針所指向的的類型是 int *
(4)int (*ptr)[3]; //指針所指向的的類型是 int()[3]
(5)int *(*ptr)[4]; //指針所指向的的類型是 int *()[4]
在指針的算術運算中，指針所指向的類型有很大的作用。
指針的類型(即指針本身的類型)和指針所指向的類型是兩個概念。當你對C越
來越熟悉時，你會發現，把與指針攪和在一起的"類型"這個概念分成"指針的
類型"和"指針所指向的類型"兩個概念，是精通指針的關鍵點之一。我看了不
少書，發現有些寫得差的書中，就把指針的這兩個概念攪在一起了，所以看起書
來前後矛盾，越看越糊塗。
3. 指針的值，或者叫指針所指向的內存區或地址。
指針的值是指針本身存儲的數值，這個值將被編譯器當作一個地址，而不是
一個一般的數值。在32位程序裡，所有類型的指針的值都是一個32位整數，因為
32位程序裡內存地址全都是32位長。
指針所指向的內存區就是從指針的值所代表的那個內存地址開始，長度為si
zeof(指針所指向的類型)的一片內存區。以後，我們說一個指針的值是XX，就相
當於說該指針指向了以XX為首地址的一片內存區域；我們說一個指針指向了某塊
內存區域，就相當於說該指針的值是這塊內存區域的首地址。
指針所指向的內存區和指針所指向的類型是兩個完全不同的概念。在例一中
，指針所指向的類型已經有了，但由於指針還未初始化，所以它所指向的內存區
是不存在的，或者說是無意義的。
以後，每遇到一個指針，都應該問問：這個指針的類型是什麼？指針指向的
類型是什麼？該指針指向了哪裡？
4. 指針本身所占據的內存區。
指針本身占了多大的內存？你只要用函數sizeof(指針的類型)測一下就知道
了。在32位平台裡，指針本身占據了4個字節的長度。
指針本身占據的內存這個概念在判斷一個指針表達式是否是左值時很有用。
第二章 指針的算術運算
指針可以加上或減去一個整數。指針的這種運算的意義和通常的數值的加減
運算的意義是不一樣的。例如：
例二：
1. char a[20];
2. int *ptr=a;
...
...
3. ptr++;
在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整
形變量a。接下來的第3句中，指針ptr被加了1，編譯器是這樣處理的：它把指針
ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由於地址是用字節做
單位的，故ptr所指向的地址由原來的變量a的地址向高地址方向增加了4個字節。
由於char類型的長度是一個字節，所以，原來ptr是指向數組a的第0號單元開始的
四個字節，此時指向了數組a中從第4號單元開始的四個字節。
我們可以用一個指針和一個循環來遍歷一個數組，看例子：
例三：
例三：
int array[20];
int *ptr=array;
...
//此處略去為整型數組賦值的代碼。
...
for(i=0;i<20;i++)
{
(*ptr)++;
ptr++；
}
這個例子將整型數組中各個單元的值加1。由於每次循環都將指針ptr加1，所
以每次循環都能訪問數組的下一個單元。
再看例子：
例四：
1. char a[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的合法范圍之外了。雖然這種情況在應用上會出問
題，但在語法上卻是可以的。這也體現出了指針的靈活性。
如果上例中，ptr是被減去5，那麼處理過程大同小異，只不過ptr的值是被減
去5乘sizeof(int)，新的ptr指向的地址將比原來的ptr所指向的地址向低地址方
向移動了20個字節。
總結一下，一個指針ptrold加上一個整數n後，結果是一個新的指針ptrnew，
ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型
也相同。ptrnew的值將比ptrold的值增加了n乘sizeof(ptrold所指向的類型)個字
節。就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向高地址方向移
動了n乘sizeof(ptrold所指向的類型)個字節。
一個指針ptrold減去一個整數n後，結果是一個新的指針ptrnew，ptrnew的類
型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。pt
rnew的值將比ptrold的值減少了n乘sizeof(ptrold所指向的類型)個字節，就是說
，ptrnew所指向的內存區將比ptrold所指向的內存區向低地址方向移動了n乘siz
eof(ptrold所指向的類型)個字節。
第三章 運算符號&和*
這裡&是取地址運算符，*是...書上叫做"間接運算符"。
&a的運算結果是一個指針，指針的類型是a的類型加個*，指針所指向的類型
是a的類型，指針所指向的地址嘛，那就是a的地址。
*p的運算結果就五花八門了。總之*p的結果是p所指向的東西，這個東西有這
些特點：它的類型是p指向的類型，它所占用的地址是p所指向的地址。
例五：
int a=12;
int b;
int *p;
int **ptr;
p=&a;//&a的結果是一個指針，類型是int*，指向的類型是int，指向的地址
是a的地址。
*p=24;//*p的結果，在這裡它的類型是int，它所占用的地址是p所指向的地
址，顯然，*p就是變量a。
ptr=&p;//&p的結果是個指針，該指針的類型是p的類型加個*，在這裡是int
**。該指針所指向的類型是p的類型，這裡是int*。該指針所指向的地址就是指針
p自己的地址。
*ptr=&b;//*ptr是個指針，&b的結果也是個指針，且這兩個指針的類型和所
指向的類型是一樣的，所以用&b來給*ptr賦值就是毫無問題的了。
**ptr=34;//*ptr的結果是ptr所指向的東西，在這裡是一個指針，對這個指
針再做一次*運算，結果就是一個int類型的變量。
第四章 指針表達式
一個表達式的最後結果如果是一個指針，那麼這個表達式就叫指針表達式。
下面是一些指針表達式的例子：
例六：
int a,b;
int array[10];
int *pa;
pa=&a;//&a是一個指針表達式。
int **ptr=&pa;//&pa也是一個指針表達式。
*ptr=&b;//*ptr和&b都是指針表達式。
pa=array;
pa++;//這也是指針表達式。
例七：
char *arr[20];
char **parr=arr;//如果把arr看作指針的話，arr也是指針表達式
char *str;
str=*parr;//*parr是指針表達式
str=*(parr+1);//*(parr+1)是指針表達式
str=*(parr+2);//*(parr+2)是指針表達式
由於指針表達式的結果是一個指針，所以指針表達式也具有指針所具有的四
個要素：指針的類型，指針所指向的類型，指針指向的內存區，指針自身占據的
內存。
好了，當一個指針表達式的結果指針已經明確地具有了指針自身占據的內存
的話，這個指針表達式就是一個左值，否則就不是一個左值。
在例七中，&a不是一個左值，因為它還沒有占據明確的內存。*ptr是一個左
值，因為*ptr這個指針已經占據了內存，其實*ptr就是指針pa，既然pa已經在內
存中有了自己的位置，那麼*ptr當然也有了自己的位置。
第五章 數組和指針的關系
如果對聲明數組的語句不太明白的話，請參閱我前段時間貼出的文?lt;<如何
理解c和c++的復雜類型聲明>>。
數組的數組名其實可以看作一個指針。看下例：
例八：
int array[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]，但如果把a
rray看做指針的話，它指向數組的第0個單元，類型是int *，所指向的類型是數
組單元的類型即int。因此*array等於0就一點也不奇怪了。同理，array+3是一個
指向數組第3個單元的指針，所以*(array+3)等於3。其它依此類推。
例九：
例九：
char *str[3]={
"Hello,this is a sample!",
"Hi,good morning.",
"Hello world"
};
char s[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,this is a sample!"的第一個字符的地址，即’H’的地址。
str+1也是一個指針，它指向數組的第1號單元，它的類型是char**，它指向
的類型是char *。
*(str+1)也是一個指針，它的類型是char*，它所指向的類型是char，它指向
"Hi,good morning."的第一個字符’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扮演的是指針，故arr
ay+n的結果是一個指針，它的類型是TYPE*，它指向的類型是TYPE，它指向數組第
n號單元。故sizeof(array+n)測出的是指針類型的大小。
例十：
int array[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(對象)測出的都是對象自身的類型的大小，而不是別的什麼
類型的大小。
第六章 指針和結構類型的關系
可以聲明一個指向結構類型對象的指針。
例十一：
struct MyStruct
{
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上調式過上述代碼，但是要知道，這樣使用p
str來訪問結構成員是不正規的，為了說明為什麼不正規，讓我們看看怎樣通過指
針來訪問數組的各個單元：
例十二：
int array[3]={35,56,37};
int *pa=array;
通過指針pa訪問數組array的三個單元的方法是：
*pa;//訪問了第0號單元
*(pa+1);//訪問了第1號單元
*(pa+2);//訪問了第2號單元
從格式上看倒是與通過指針訪問結構成員的不正規方法的格式一樣。
所有的C/C++編譯器在排列數組的單元時，總是把各個數組單元存放在連續的
存儲區裡，單元和單元之間沒有空隙。但在存放結構對象的各個成員時，在某種
編譯環境下，可能會需要字對齊或雙字對齊或者是別的什麼對齊，需要在相鄰兩
個成員之間加若干?quot;填充字節"，這就導致各個成員之間可能會有若干個字節
的空隙。
所以，在例十二中，即使*pstr訪問到了結構對象ss的第一個成員變量a，也
不能保證*(pstr+1)就一定能訪問到結構成員b。因為成員a和成員b之間可能會有
若干填充字節，說不定*(pstr+1)就正好訪問到了這些填充字節呢。這也證明了指
針的靈活性。要是你的目的就是想看看各個結構成員之間到底有沒有填充字節，
嘿，這倒是個不錯的方法。
通過指針訪問結構成員的正確方法應該是象例十二中使用指針ptr的方法。
第七章 指針和函數的關系
可以把一個指針聲明成為一個指向函數的指針。
int fun1(char*,int);
int (*pfun1)(char*,int);
pfun1=fun1;
....
....
int a=(*pfun1)("abcdefg",7);//通過函數指針調用函數。
可以把指針作為函數的形參。在函數調用語句中，可以用指針表達式來作為
實參。
例十三：
int fun(char*);
int a;
char str[]="abcdefghijklmn";
a=fun(str);
...
...
int fun(char*s)
{
int num=0;
for(int i=0;i
{
num+=*s;s++;
}
return num;
)
這個例子中的函數fun統計一個字符串中各個字符的ASCII碼值之和。前面說
了，數組的名字也是一個指針。在函數調用中，當把str作為實參傳遞給形參s後
，實際是把str的值傳遞給了s，s所指向的地址就和str所指向的地址一致，但是
str和s各自占用各自的存儲空間。在函數體內對s進行自加1運算，並不意味著同
時對str進行了自加1運算。
第八章 指針類型轉換
當我們初始化一個指針或給一個指針賦值時，賦值號的左邊是一個指針，賦
值號的右邊是一個指針表達式。在我們前面所舉的例子中，絕大多數情況下，指
針的類型和指針表達式的類型是一樣的，指針所指向的類型和指針表達式所指向
的類型是一樣的。
例十四：
1.float f=12.3;
2. float *fptr=&f;
3. int *p;
在上面的例子中，假如我們想讓指針p指向實數f，應該怎麼搞？是用下面的
語句嗎？
p=&f;
不對。因為指針p的類型是int*，它指向的類型是int。表達式&f的結果是一
個指針，指針的類型是float*,它指向的類型是float。兩者不一致，直接賦值的
方法是不行的。至少在我的MSVC++6.0上，對指針的賦值語句要求賦值號兩邊的類
型一致，所指向的類型也一致，其它的編譯器上我沒試過，大家可以試試。為了
實現我們的目的，需要進行"強制類型轉換"：
p=(int*)&f;
如果有一個指針p，我們需要把它的類型和所指向的類型改為TYEP*和TYPE，
那麼語法格式是：
(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的首地址。
我們已經知道，指針的值就是指針指向的地址，在32位程序中，指針的值其
實是一個32位整數。那可不可以把一個整數當作指針的值直接賦給指針呢？就象
下面的語句：
unsigned int a;
TYPE *ptr;//TYPE是int，char或結構類型等等類型。
...
...
a=20345686;
ptr=20345686;//我們的目的是要使指針ptr指向地址20345686（十進制
）
ptr=a;//我們的目的是要使指針ptr指向地址20345686（十進制）
編譯一下吧。結果發現後面兩條語句全是錯的。那麼我們的目的就不能達到
了嗎？不，還有辦法：
unsigned int a;
TYPE *ptr;//TYPE是int，char或結構類型等等類型。
...
...
a=某個數，這個數必須代表一個合法的地址；
ptr=(TYPE*)a；//呵呵，這就可以了。
嚴格說來這裡的(TYPE*)和指針類型轉換中的(TYPE*)還不一樣。這裡的(TYP
E*)的意思是把無符號整數a的值當作一個地址來看待。
上面強調了a的值必須代表一個合法的地址，否則的話，在你使用ptr的時候
，就會出現非法操作錯誤。
想想能不能反過來，把指針指向的地址即指針的值當作一個整數取出來。完
全可以。下面的例子演示了把一個指針的值當作一個整數取出來，然後再把這個
整數當作一個地址賦給一個指針：
例十六：
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所指向的存儲區時是不安全的。至於為什麼，讀者結合例十七來想一
想，應該會明白的。
