第一篇：C++“指針”學(xué)習(xí)建議

一.對于眾多人提出的c/c++中指針難學(xué)的問題做個(gè)總結(jié)：

指針學(xué)習(xí)不好關(guān)鍵是概念不清造成的，說的簡單點(diǎn)就是書沒有認(rèn)真看，指針的學(xué)習(xí)猶如人在學(xué)習(xí)饒口令不多看多學(xué)多練是不行的，下面是兩個(gè)很經(jīng)典的例子，很多書上都有,對于學(xué)習(xí)的重點(diǎn)在于理解*x和x的理解，他們并不相同，*x所表示的其實(shí)就是變量a本身，x表示的是變量a在內(nèi)存中的地址，如果想明白可以輸出觀察cout<<*x“|”x;，當(dāng)定義了int *x;后對x=&a的理解的問題。仔細(xì)閱讀和聯(lián)系下面的兩個(gè)例子我想指針問題就不是難點(diǎn)了！

#include main(){ int a,b;/* 定義a,b兩個(gè)整形變量用于輸入兩個(gè)整數(shù) */ int *point_1,*point_2,*temp_point;/* 定義三個(gè)指針變量 */ scanf(“%d,%d”,&a,&b);/* 格式化輸入a,b的值 */

point_1=&a;/* 把指針變量point_1的值指向變量a的地址 */ point_2=&b;/* 把指針變量point_2的值指向變量b的地址 */ if(a main(){ int a,b;/* 定義a,b兩個(gè)整形變量用于輸入兩個(gè)整數(shù) */ int *point_1,*point_2;/* 定義三個(gè)指針變量 */ scanf(“%d,%d”,&a,&b);/* 格式化輸入a,b的值 */

point_1 = &a;/* 把指針變量point_1的值指向變量a的地址 */ point_2 = &b;/* 把指針變量point_2的值指向變量b的地址 */

compositor(point_1,point_2);/* 調(diào)用自定義的排序涵數(shù),把a(bǔ),b的地址傳遞給point_1和point_2 */ printf(“%d,%d”,a,b);/* 打印出a,b的值 */ } static compositor(p1,p2)int *p1,*p2;/* 定義形式參數(shù)p1,p2為指針變量 */ { int temp;/* 建立臨時(shí)存儲變量 */

if(*p1<*p2)/* 如果*p1

*p1 = *p2;/* 將*p1的值也就是a的值換成*p2的值也就是b的值,等價(jià)于a=b */ *p2 = temp;/* 將*p2的值也就是temp的值等價(jià)于b=temp */ } } /* 注意:此題與上題不同的是,直接改變了a于b的值達(dá)到真實(shí)改變的目的 */

二．C++指針使用方法解惑

“void ClearList(LNode * & HL)”

仔細(xì)看一下這種聲明方式，確實(shí)有點(diǎn)讓人迷惑。

下面以void func1（MYCLASS *&pBuildingElement）； 為例來說明這個(gè)問題。在某種意義上，“*”和“&”是意思相對的兩個(gè)東西，把它們放在一起有什么意義呢？。為了理解指針的這種做法，我們先復(fù)習(xí)一下C/C++編程中無所不在的指針概念。我們都知道MYCLASS*的意思：指向某個(gè)對象的指針，此對象的類型為MYCLASS。Void func1（MYCLASS *pMyClass）；

// 例如： MYCLASS* p = new MYCLASS； func1（p）；

上面這段代碼的這種處理方法想必誰都用過，創(chuàng)建一個(gè)MYCLASS對象，然后將它傳入func1函數(shù)。現(xiàn)在假設(shè)此函數(shù)要修改pMyClass： void func1（MYCLASS *pMyClass）{ DoSomething（pMyClass）； pMyClass = // 其它對象的指針 }

第二條語句在函數(shù)過程中只修改了pMyClass的值。并沒有修改調(diào)用者的變量p的值。如果p指向某個(gè)位于地址0x008a00的對象，當(dāng)func1返回時(shí)，它仍然指向這個(gè)特定的對象。（除非func1有bug將堆弄亂了，完全有這種可能。）

現(xiàn)在假設(shè)你想要在func1中修改p的值。這是你的權(quán)利。調(diào)用者傳入一個(gè)指針，然后函數(shù)給這個(gè)指針賦值。以往一般都是傳雙指針，即指針的指針，例如，CMyClass**。MYCLASS* p = NULL； func1（&p）；

void func1（MYCLASS** pMyClass）； { *pMyClass = new MYCLASS； ?? }

調(diào)用func1之后，p指向新的對象。在COM編程中，你到處都會(huì)碰到這樣的用法--例如在查詢對象接口的QueryInterface函數(shù)中： interface ISomeInterface { HRESULT QueryInterface（IID &iid, void** ppvObj）； ?? }；

LPSOMEINTERFACE p=NULL；

pOb->QueryInterface（IID_SOMEINTERFACE, &p）；

此處，p是SOMEINTERFACE類型的指針，所以&p便是指針的指針，在QueryInterface返回的時(shí)候，如果調(diào)用成功，則變量p包含一個(gè)指向新的接口的指針。

如果你理解指針的指針，那么你肯定就理解指針引用，因?yàn)樗鼈兺耆且换厥隆Ｈ绻阆笙旅孢@樣聲明函數(shù)： void func1（MYCLASS *&pMyClass）； { pMyClass = new MYCLASS； ?? } 其實(shí)，它和前面所講得指針的指針例子是一碼事，只是語法有所不同。傳遞的時(shí)候不用傳p的地址&p，而是直接傳p本身：

MYCLASS* p = NULL；

func1（p）；

在調(diào)用之后，p指向一個(gè)新的對象。一般來講，引用的原理或多或少就象一個(gè)指針，從語法上看它就是一個(gè)普通變量。所以只要你碰到*&，就應(yīng)該想到**。也就是說這個(gè)函數(shù)修改或可能修改調(diào)用者的指針，而調(diào)用者象普通變量一樣傳遞這個(gè)指針，不使用地址操作符&。

至于說什么場合要使用這種方法，我會(huì)說，極少。MFC在其集合類中用到了它--例如，CObList，它是一個(gè)Cobjects指針列表。

Class CObList : public Cobject { ??

// 獲取/修改指定位置的元素

Cobject*& GetAt（POSITION position）； Cobject* GetAt（POSITION position）const； }；

這里有兩個(gè)GetAt函數(shù)，功能都是獲取給定位置的元素。區(qū)別何在呢？

區(qū)別在于一個(gè)讓你修改列表中的對象，另一個(gè)則不行。所以如果你寫成下面這樣： Cobject* pObj = mylist.GetAt（pos）；

則pObj是列表中某個(gè)對象的指針，如果接著改變pObj的值： pObj = pSomeOtherObj；

這并改變不了在位置pos處的對象地址，而僅僅是改變了變量pObj。但是，如果你寫成下面這樣： Cobject*& rpObj = mylist.GetAt（pos）；

現(xiàn)在，rpObj是引用一個(gè)列表中的對象的指針，所以當(dāng)改變r(jià)pObj時(shí)，也會(huì)改變列表中位置pos處的對象地址--換句話說，替代了這個(gè)對象。這就是為什么CObList會(huì)有兩個(gè)GetAt函數(shù)的緣故。一個(gè)可以修改指針的值，另一個(gè)則不能。注意我在此說的是指針，不是對象本身。這兩個(gè)函數(shù)都可以修改對象，但只有*&版本可以替代對象。

在C/C++中引用是很重要的，同時(shí)也是高效的處理手段。所以要想成為C/C++高手，對引用的概念沒有透徹的理解和熟練的應(yīng)用是不行的。

三．?dāng)?shù)據(jù)指針

在C/C++語言中一直是很受寵的；幾乎找不到一個(gè)不使用指針的C/C++應(yīng)用。用于存儲數(shù)據(jù)和程序的地址，這是指針的基本功能。用于指向整型數(shù)，用整數(shù)指針(int*)；指向浮點(diǎn)數(shù)用浮點(diǎn)數(shù)指針(float*)；指向結(jié)構(gòu)，用對應(yīng)的結(jié)構(gòu)指針(struct xxx *)；指向任意地址，用無類型指針(void*)。

有時(shí)候，我們需要一些通用的指針。在C語言當(dāng)中，(void*)可以代表一切；但是在C++中，我們還有一些比較特殊的指針，無法用(void*)來表示。事實(shí)上，在C++中，想找到一個(gè)通用的指針，特別是通用的函數(shù)指針簡直是一個(gè)“不可能任務(wù)”。

C++是一種靜態(tài)類型的語言，類型安全在C++中舉足輕重。在C語言中，你可以用void*來指向一切；但在C++中，void*并不能指向一切，就算能，也失去了類型安全的意義了。類型安全往往能幫我們找出程序中潛在的一些BUG。

下面我們來探討一下，C++中如何存儲各種類型數(shù)據(jù)的指針。

C++指針探討

（一）數(shù)據(jù)指針 沐楓網(wǎng)志

1.數(shù)據(jù)指針

數(shù)據(jù)指針分為兩種：常規(guī)數(shù)據(jù)指針和成員數(shù)據(jù)指針

1.1 常規(guī)數(shù)據(jù)指針

這個(gè)不用說明了，和C語言一樣，定義、賦值是很簡單明了的。常見的有：int*, double* 等等。

如：

int value = 123;int * pn = &value;

1.2 成員數(shù)據(jù)指針

有如下的結(jié)構(gòu)： struct MyStruct { int key;int value;};

現(xiàn)在有一個(gè)結(jié)構(gòu)對象: MyStruct me;MyStruct* pMe = &me;

我們需要 value 成員的地址，我們可以： int * pValue = &me.value;//或

int * pValue = &pMe->value;

當(dāng)然了，這個(gè)指針仍然是屬于第一種范籌----常規(guī)數(shù)據(jù)指針。

好了，我們現(xiàn)在需要一種指針，它指向MyStruct中的任一數(shù)據(jù)成員，那么它應(yīng)該是這樣的子： int MyStruct::* pMV = &MyStruct::value;//或

int MyStruct::* pMK = &MyStruct::key;

這種指針的用途是用于取得結(jié)構(gòu)成員在結(jié)構(gòu)內(nèi)的地址。我們可以通過該指針來訪問成員數(shù)據(jù)： int value = pMe->*pMV;// 取得pMe的value成員數(shù)據(jù)。

int key = me.*pMK;// 取得me的key成員數(shù)據(jù)。

那么，在什么場合下會(huì)使用到成員數(shù)據(jù)指針呢？

確實(shí)，成員指針本來就不是一種很常用的指針。不過，在某些時(shí)候還是很有用處的。我們先來看看下面的一個(gè)函數(shù)： int sum(MyStruct* objs, int MyStruct::* pm, int count){ int result = 0;for(int i = 0;i < count;++i)result += objs[i].*pm;return result;}

這個(gè)函數(shù)的功能是什么，你能看明白嗎？它的功能就是，給定count個(gè)MyStruct結(jié)構(gòu)的指針，計(jì)算出給定成員數(shù)據(jù)的總和。有點(diǎn)拗口對吧？看看下面的程序，你也許就明白了：

MyStruct me[10] = { {1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20} };int sum_value = sum(me, &MyStruct::value, 10);//計(jì)算10個(gè)MyStruct結(jié)構(gòu)的value成員的總和： sum_value 值 為 110(2+4+6+8+ int sum_key = sum(me, &MyStruct::key, 10);//計(jì)算10個(gè)MyStruct結(jié)構(gòu)的key成員的總和： sum_key 值 為 100(1+3+5+7+

+19)+20)也許，你覺得用常規(guī)指針也可以做到，而且更易懂。Ok，沒問題： int sum(MyStruct* objs, int count){ int result = 0;for(int i = 0;i < count;++i)result += objs[i].value;return result;}

你是想這么做嗎？但這么做，你只能計(jì)算value，如果要算key的話，你要多寫一個(gè)函數(shù)。有多少個(gè)成員需要計(jì)算的話，你就要寫多少個(gè)函數(shù)，多麻煩啊。指針

四．C++指針使用

在下列函數(shù)聲明中，為什么要同時(shí)使用*和&符號？以及什么場合使用這種聲明方式?

void func1(MYCLASS *&pBuildingElement);論壇中經(jīng)常有人問到這樣的問題。

本文試圖通過一些實(shí)際的指針使用經(jīng)驗(yàn)來解釋這個(gè)問題。

仔細(xì)看一下這種聲明方式，確實(shí)有點(diǎn)讓人迷惑。在某種意義上，“*”和“&”是意思相對的兩個(gè)東西，把它們放在一起有什么意義呢？。為了理解指針的這種做法，我們先復(fù)習(xí)一下C/C++編程中無所不在的指針概念。我們都知道MYCLASS*的意思：指向某個(gè)對象的指針，此對象的類型為MYCLASS。void func1(MYCLASS *pMyClass);

// 例如： MYCLASS* p = new MYCLASS;

func1(p);

上面這段代碼的這種處理方法想必誰都用過，創(chuàng)建一個(gè)MYCLASS對象，然后將它傳入func1函數(shù)。現(xiàn)在假設(shè)此函數(shù)要修改pMyClass： void func1(MYCLASS *pMyClass){ DoSomething(pMyClass);pMyClass = // 其它對象的指針 }

第二條語句在函數(shù)過程中只修改了pMyClass的值。并沒有修改調(diào)用者的變量p的值。如果p指向某個(gè)位于地址0x008a00的對象，當(dāng)func1返回時(shí)，它仍然指向這個(gè)特定的對象。（除非func1有bug將堆弄亂了，完全有這種可能。）

現(xiàn)在假設(shè)你想要在func1中修改p的值。這是你的權(quán)利。調(diào)用者傳入一個(gè)指針，然后函數(shù)給這個(gè)指針賦值。以往一般都是傳雙指針，即指針的指針，例如，CMyClass**。MYCLASS* p = NULL;func1(&p);void func1(MYCLASS** pMyClass);{ *pMyClass = new MYCLASS;?? }

調(diào)用func1之后，p指向新的對象。在COM編程中，你到處都會(huì)碰到這樣的用法--例如在查詢對象接口的QueryInterface函數(shù)中：

interface ISomeInterface { HRESULT QueryInterface(IID &iid, void** ppvObj);?? };

LPSOMEINTERFACE p=NULL;pOb->QueryInterface(IID_SOMEINTERFACE, &p);

此處，p是SOMEINTERFACE類型的指針，所以&p便是指針的指針，在QueryInterface返回的時(shí)候，如果調(diào)用成功，則變量p包含一個(gè)指向新的接口的指針。

如果你理解指針的指針，那么你肯定就理解指針引用，因?yàn)樗鼈兺耆且换厥隆Ｈ绻阆笙旅孢@樣聲明函數(shù)： void func1(MYCLASS *&pMyClass);{ pMyClass = new MYCLASS;?? } 其實(shí)，它和前面所講得指針的指針例子是一碼事，只是語法有所不同。傳遞的時(shí)候不用傳p的地址&p，而是直接傳p本身：

MYCLASS* p = NULL;func1(p);在調(diào)用之后，p指向一個(gè)新的對象。一般來講，引用的原理或多或少就象一個(gè)指針，從語法上看它就是一個(gè)普通變量。所以只要你碰到*&，就應(yīng)該想到**。也就是說這個(gè)函數(shù)修改或可能修改調(diào)用者的指針，而調(diào)用者象普通變量一樣傳遞這個(gè)指針，不使用地址操作符&。

至于說什么場合要使用這種方法，我會(huì)說，極少。MFC在其集合類中用到了它--例如，CObList，它是一個(gè)CObjects指針列表。

class CObList : public CObject { ??

// 獲取/修改指定位置的元素

CObject*& GetAt(POSITION position);CObject* GetAt(POSITION position)const;};這里有兩個(gè)GetAt函數(shù)，功能都是獲取給定位置的元素。區(qū)別何在呢？

區(qū)別在于一個(gè)讓你修改列表中的對象，另一個(gè)則不行。所以如果你寫成下面這樣： CObject* pObj = mylist.GetAt(pos);

則pObj是列表中某個(gè)對象的指針，如果接著改變pObj的值： pObj = pSomeOtherObj;

這并改變不了在位置pos處的對象地址，而僅僅是改變了變量pObj。但是，如果你寫成下面這樣： CObject*& rpObj = mylist.GetAt(pos);

現(xiàn)在，rpObj是引用一個(gè)列表中的對象的指針，所以當(dāng)改變r(jià)pObj時(shí)，也會(huì)改變列表中位置pos處的對象地址--換句話說，替代了這個(gè)對象。這就是為什么CObList會(huì)有兩個(gè)GetAt函數(shù)的緣故。一個(gè)可以修改指針的值，另一個(gè)則不能。注意我在此說的是指針，不是對象本身。這兩個(gè)函數(shù)都可以修改對象，但只有*&版本可以替代對象。

在C/C++中引用是很重要的，同時(shí)也是高效的處理手段。所以要想成為C/C++高手，對引用的概念沒有透徹的理解和熟練的應(yīng)用是不行的。

五．新手學(xué)習(xí)之淺析c/c++中的指針

在學(xué)習(xí)c/c+過程中，指針是一個(gè)比較讓人頭痛的問題，稍微不注意將會(huì)是程序編譯無法通過，甚至造成死機(jī)。在程序設(shè)計(jì)過程中，指針也往往是產(chǎn)生隱含bug的原因。下面就來談?wù)勚羔樀膽?yīng)用以及需要注意的一些問題，里面也許就有你平時(shí)沒有注意到的問題，希望能幫助各位讀者理解好指針。

一、我們先來回憶一下指針的概念吧，方便下面的介紹

指針是存放地址值的變量或者常量。例如：int a=1;&a就表示指針常量（“&”表示取地址運(yùn)算符，也即引用）。int *b，b表示的是指針變量（注意，是b表示指針變量而不是*b），*表示要說明的是指針變量。大家注意int *b[2]和int（*b）[2]是不同的，int *b表示一個(gè)指針數(shù)組，而int（*b）[2]表示含有兩個(gè)元素的int指針，這里要注意運(yùn)算優(yōu)先級問題，有助于理解指針問題。在這里大概介紹基本概念就夠了，至于具體使用方法，如賦值等，很多書都有介紹，我就不多說了。

二、應(yīng)用以及注意的問題

1、理解指針的關(guān)鍵所在——對指針類型和指針?biāo)赶虻念愋偷睦斫?/p>

①、指針類型：可以把指針名字去掉，剩下的就是這個(gè)指針

例如： int *a;//指針類型為int *

int **a;//指針類型為int **

int *(*a)[8];//指針類型為 int *(*)[8]

②、指針?biāo)赶虻念愋停菏侵妇幾g器將把那一片內(nèi)存所看待成的類型。這里只要把指針聲明語句中的指針名字和名字右邊的“*”號去掉就可以了，剩下的就是指針?biāo)赶虻念愋汀?/p>

我之所以把他們放在第一位，是因?yàn)榕宄麄兪菍W(xué)c/c++指針的重點(diǎn)，正確理解他們才能使你打好c/c++的編程基礎(chǔ)。

2、指針的應(yīng)用——傳遞參數(shù)。

其實(shí)它可以相當(dāng)于隱式的返回值，這就比return的方法更加靈活了，可以返回更多的值，看看下面的例子自然就明白了：

#include “iostream.h”

void example(int *a1,int &b1,int c1)

{

*a1*=3;

++b1;

++c1;

}

void main()

{

int *a;

int b,c;

*a=6;

b=7;c=10;

example(a,b,c);

cout <<“*a=”<<*a<

cout <<“b=”<

cout <<“c=”<

}

輸出：*a=18

b=8

c=10

注意到?jīng)]有，*a和b的值都改變了，而c沒有變。這是由于a1是指向*a（=6）的指針，也即與a是指向同一個(gè)地址，所以當(dāng)a1指向的值改變了，*a的值也就改變了。在函數(shù)中的參數(shù)使用了引用（int &b1），b1是b的別名，也可以把它當(dāng)作特殊的指針來理解，所以b的值會(huì)改變。函數(shù)中的參數(shù)int c1只是在函數(shù)中起作用，當(dāng)函數(shù)結(jié)束時(shí)候便消失了，所以在main（）中不起作用。

3、關(guān)于全局變量和局部變量的一個(gè)問題先不廢話了，先看看程序：

#include “iostream.h”

int a=5;

int *example1(int b)

{

a+=b;

return &a;

}

int *example2(int b)

{

int c=5;

b+=c;

return &b;

}

void main()

{

int *a1=example1(10);

int *b1=example2(10);

cout <<”a1=”<<*a1<

cout <<”b1=”<<*b1<

}

輸出結(jié)果：

a1=15

b1=4135

*b1怎么會(huì)是4135，而不是15呢？是程序的問題？沒錯(cuò)吧？

由于a是全局變量，存放在全局變量的內(nèi)存區(qū)，它一直是存在的；而局部變量則是存在于函數(shù)的棧區(qū)，當(dāng)函數(shù)example2（）調(diào)用結(jié)束后便消失，是b指向了一個(gè)不確定的區(qū)域，產(chǎn)生指針懸掛。

下面是對example1（）和example2（）的反匯編（用TC++ 3.0編譯）：

example1（）：

push bp;入棧

mov bp,sp mov ax,[bp+04];傳遞參數(shù)

add [00AA],ax;相加

mov ax,00AA;返回了結(jié)果所在的地址

..pop bp；恢復(fù)棧，出棧

ret；退出函數(shù)

example2（）：

push bp；入棧

mov bp,sp

sub sp,02

mov word ptr [bp-02],0005

mov ax,[bp-02]；傳遞參數(shù)

add [bp+04],ax;相加

lea ax,[bp+04];問題就出在這里

..mov sp,bp

pop bp；恢復(fù)棧，出棧

ret；退出函數(shù)

對比之后看出來了吧？ax應(yīng)該是存儲的是結(jié)果的地址。而在example2（）中，返回的卻是[bp+04]的內(nèi)容，因此指針指向了一個(gè)不確定的地方，由此產(chǎn)生的指針懸掛。example1（）中，ax返回了正確的結(jié)果的地址。

4、內(nèi)存問題：使用指針注意內(nèi)存的分配和邊界。使用指針過程中應(yīng)該給變量一個(gè)適當(dāng)?shù)目臻g，以免產(chǎn)生不可見的錯(cuò)誤。請看以下代碼：

#include “iostream.h”

void main()

{

char *a1;

char *a2;

cin >>a1;

cin >>a2;

cout <<”a1=”<

cout <<”a2=”<

}

輸入：abc

123

輸出：

a1=123

a2=

Null pointer assignment

指針指向了“空”。解決辦法就是分配適當(dāng)?shù)膬?nèi)存給這兩個(gè)字符串。修正后的代碼

如下：

#include “iostream.h”

void main()

{

char *a1;

char *a2;

a1=new char [10];

a2=new char [10];

cin >>a1;

cin >>a2;

cout <<”a1=”<

cout <<”a2=”<

delete(a1);注意,別忘了要釋放內(nèi)存空間

delete(a2);

}

到此就能輸出正確的結(jié)果了。分配了適當(dāng)?shù)膬?nèi)存之后要注意釋放內(nèi)參空間，同時(shí)還應(yīng)該注意不要超出所分配的內(nèi)存的大小，否則會(huì)有溢出現(xiàn)象產(chǎn)生，導(dǎo)致不可預(yù)料的結(jié)果。

5、關(guān)于特殊的指針——引用

引用有時(shí)候應(yīng)用起來要比指針要靈活，用它做返回的時(shí)候是不產(chǎn)生任何變量的副本的這樣減小了內(nèi)存的占用，提高執(zhí)行的速度。引用使用起來要比指針好理解，比較直觀。當(dāng)引用作為參數(shù)時(shí)，不會(huì)改變參數(shù)的地址，因此可以作為左值。

下面請看一個(gè)例子：

#include “iostream.h”

char ch[5]=”ABCD”;

char &example(int b)

{

return ch;

}

void main()

{

cout <<”ch=”<

example(2)=”c”;

cout<<”ch=”<

}

輸出結(jié)果：

ch=ABCD

ch=ABcD

在實(shí)際編程過程中，可以靈活地引用或指針，盡量提高程序的可讀性和執(zhí)行效率。

三、小結(jié)：

指針是學(xué)習(xí)c/c++的重點(diǎn)難點(diǎn)，主要原因是指針較為抽象，不容易理解。使用指針千萬要明白讓指針指向什么地方，如何讓指針指向正確的地方。在深入系統(tǒng)底層之中需要應(yīng)用到大量的指針，因此需要理解好指針的基本概念，例如：指針類型和指針?biāo)赶虻念愋汀Ｆ綍r(shí)應(yīng)該對留心觀察，了解程序的工作過程，必要時(shí)候可以對程序進(jìn)行反匯編，加深對指針的理解，這種方法同樣適合學(xué)別的編程方面的知識。

四、結(jié)束：

指針的應(yīng)用是很廣泛的，利用指針可以做很多事情，要成為一個(gè)好的程序員，必須對指針有比較深刻的了解。寫本文的目的在于讓大家對指針有更深一層的了解，提高指針的應(yīng)用能力，內(nèi)容大都是我在實(shí)際編程中遇到的問題。相信能給大家一定的幫助。

六．C++中關(guān)于指針入門的最好的文章

什么是指針？

其實(shí)指針就像是其它變量一樣，所不同的是一般的變量包含的是實(shí)際的真實(shí)的數(shù)據(jù)，而指針是一個(gè)指示器，它告訴程序在內(nèi)存的哪塊區(qū)域可以找到數(shù)據(jù)。這是一個(gè)非常重要的概念，有很多程序和算法都是圍繞指針而設(shè)計(jì)的，如鏈表。

開始學(xué)習(xí)

如何定義一個(gè)指針呢？就像你定義一個(gè)其它變量一樣，只不過你要在指針名字前加上一個(gè)星號。我們來看一個(gè)例子：下面這個(gè)程序定義了兩個(gè)指針，它們都是指向整型數(shù)據(jù)。

int* pNumberOne;

int* pNumberTwo;

你注意到在兩個(gè)變量名前的“p”前綴了嗎？這是程序員通常在定義指針時(shí)的一個(gè)習(xí)慣，以提高便程序的閱讀性，表示這是個(gè)指針。現(xiàn)在讓我們來初始化這兩個(gè)指針：

pNumberOne = &some_number;

pNumberTwo = &some_other_number;

&號讀作“什么的地址”，它表示返回的是變量在內(nèi)存中的地址而不是變量本身的值。在這個(gè)例子中，pNumberOne 等于some_number的地址，所以現(xiàn)在pNumberOne指向some_number。如果現(xiàn)在我們在程序中要用到some_number，我們就可以使用pNumberOne。

我們來學(xué)習(xí)一個(gè)例子：

在這個(gè)例子中你將學(xué)到很多，如果你對指針的概念一點(diǎn)都不了解，我建議你多看幾遍這個(gè)例子，指針是個(gè)很復(fù)雜的東西，但你會(huì)很快掌握它的。

這個(gè)例子用以增強(qiáng)你對上面所介紹內(nèi)容的了解。它是用C編寫的(注：原英文版是用C寫的代碼，譯者重新用C++改寫寫了所有代碼，并在DEV C++ 和VC++中編譯通過！）

#include

void main()

{ // 聲明變量：

int nNumber;

int *pPointer;

// 現(xiàn)在給它們賦值：

nNumber = 15;

pPointer = &nNumber;

//打印出變量nNumber的值：

cout<<“nNumber is equal to :”<< nNumber<

// 現(xiàn)在通過指針改變nNumber的值：

*pPointer = 25;

//證明nNumber已經(jīng)被上面的程序改變

//重新打印出nNumber的值:

cout<<“nNumber is equal to :”<

}

通讀一下這個(gè)程序，編譯并運(yùn)行它，務(wù)必明白它是怎樣工作的。如果你完成了，準(zhǔn)備好，開始下一小節(jié)。

陷井！

試一下，你能找出下面這段程序的錯(cuò)誤嗎？

#include

int *pPointer;

void SomeFunction();

{

int nNumber;

nNumber = 25;

//讓指針指向nNumber:

pPointer = &nNumber;

}

void main()

{

SomeFunction();//為pPointer賦值

//為什么這里失敗了?為什么沒有得到25

cout<<“Value of *pPointer: ”<<*pPointer<

}

這段程序先調(diào)用了SomeFunction函數(shù)，創(chuàng)建了個(gè)叫nNumber的變量，接著讓指針pPointer指向了它。可是問題出在哪兒呢？當(dāng)函數(shù)結(jié)束后，nNumber被刪掉了，因?yàn)檫@一個(gè)局部變量。局部變量在定義它的函數(shù)執(zhí)行完后都會(huì)被系統(tǒng)自動(dòng)刪掉。也就是說當(dāng)SomeFunction 函數(shù)返回主函數(shù)main()時(shí)，這個(gè)變量已經(jīng)被刪掉，但pPointer還指著變量曾經(jīng)用過的但現(xiàn)在已不屬于這個(gè)程序的區(qū)域。如果你還不明白，你可以再讀讀這個(gè)程序，注意它的局部變量和全局變量，這些概念都非常重要。

但這個(gè)問題怎么解決呢？答案是動(dòng)態(tài)分配技術(shù)。注意這在C和C++中是不同的。由于大多數(shù)程序員都是用C++，所以我用到的是C++中常用的稱謂。

動(dòng)態(tài)分配

動(dòng)態(tài)分配是指針的關(guān)鍵技術(shù)。它是用來在不必定義變量的情況下分配內(nèi)存和讓指針去指向它們。盡管這么說可能會(huì)讓你迷惑，其實(shí)它真的很簡單。下面的代碼就是一個(gè)為一個(gè)整型數(shù)據(jù)分配內(nèi)存的例子：

int *pNumber;

pNumber = new int;

第一行聲明一個(gè)指針pNumber。第二行為一個(gè)整型數(shù)據(jù)分配一個(gè)內(nèi)存空間，并讓pNumber指向這個(gè)新內(nèi)存空間。下面是一個(gè)新例，這一次是用double雙精型：

double *pDouble;

pDouble = new double;

這種格式是一個(gè)規(guī)則，這樣寫你是不會(huì)錯(cuò)的。

但動(dòng)態(tài)分配又和前面的例子有什么不同呢？就是在函數(shù)返回或執(zhí)行完畢時(shí)，你分配的這塊內(nèi)存區(qū)域是不會(huì)被刪除的所以我們現(xiàn)在可以用動(dòng)態(tài)分配重寫上面的程序：

#include

int *pPointer;

void SomeFunction()

{ // 讓指針指向一個(gè)新的整型

pPointer = new int;

*pPointer = 25;

}

void main()

{

SomeFunction();// 為pPointer賦值

cout<<“Value of *pPointer: ”<<*pPointer<

}

通讀這個(gè)程序，編譯并運(yùn)行它，務(wù)必理解它是怎樣工作的。當(dāng)SomeFunction調(diào)用時(shí)，它分配了一個(gè)內(nèi)存，并讓pPointer指向它。這一次，當(dāng)函數(shù)返回時(shí)，新的內(nèi)存區(qū)域被保留下來，所以pPointer始終指著有用的信息，這是因?yàn)榱藙?dòng)態(tài)分配。但是你再仔細(xì)讀讀上面這個(gè)程序，雖然它得到了正確結(jié)果，可仍有一個(gè)嚴(yán)重的錯(cuò)誤。

分配了內(nèi)存，別忘了回收

太復(fù)雜了，怎么會(huì)還有嚴(yán)重的錯(cuò)誤！其實(shí)要改正并不難。問題是：你動(dòng)態(tài)地分配了一個(gè)內(nèi)存空間，可它絕不會(huì)被自動(dòng)刪除。也就是說，這塊內(nèi)存空間會(huì)一直存在，直到你告訴電腦你已經(jīng)使用完了。可結(jié)果是，你并沒有告訴電腦你已不再需要這塊內(nèi)存空間了，所以它會(huì)繼續(xù)占據(jù)著內(nèi)存空間造成浪費(fèi)，甚至你的程序運(yùn)行完畢，其它程序運(yùn)行時(shí)它還存在。當(dāng)這樣的問題積累到一定程度，最終將導(dǎo)致系統(tǒng)崩潰。所以這是很重要的，在你用完它以后，請釋放它的空間，如：

delete pPointer;

這樣就差不多了，你不得不小心。在這你終止了一個(gè)有效的指針（一個(gè)確實(shí)指向某個(gè)內(nèi)存的指針）。下面的程序，它不會(huì)浪費(fèi)任何的內(nèi)存：

#include

int *pPointer;

void SomeFunction()

{ // 讓指針指向一個(gè)新的整型

pPointer = new int;

*pPointer = 25;

}

void main()

{

SomeFunction();//為pPointer賦值

cout<<“Value of *pPointer: ”<<*pPointer<

delete pPointer;

}

只有一行與前一個(gè)程序不同，但就是這最后一行十分地重要。如果你不刪除它，你就會(huì)制造一起“內(nèi)存漏洞”，而讓內(nèi)存逐漸地泄漏。(譯者:假如在程序中調(diào)用了兩次SomeFunction，你又該如何修改這個(gè)程序呢？請讀者自己思考)

傳遞指針到函數(shù)

傳遞指針到函數(shù)是非常有用的，也很容易掌握。如果我們寫一個(gè)程序，讓一個(gè)數(shù)加上5,看一看這個(gè)程序完整嗎？：

#include

void AddFive(int Number)

{

Number = Number + 5;

}

void main()

{

int nMyNumber = 18;

cout<<“My original number is ”<

AddFive(nMyNumber);

cout<<“My new number is ”<

}

問題出在函數(shù)AddFive里用到的Number是變量nMyNumber的一個(gè)副本而傳遞給函數(shù)，而不是變量本身。因此，“ Number = Number + 5” 這一行是把變量的副本加了5，而原始的變量在主函數(shù)main()里依然沒變。試著運(yùn)行這個(gè)程序，自己去體會(huì)一下。要解決這個(gè)問題，我們就要傳遞一個(gè)指針到函數(shù)，所以我們要修改一下函數(shù)讓它能接受指針：把'void AddFive(int Number)' 改成 'void AddFive(int*Number)'。下面就是改過的程序，注意函數(shù)調(diào)用時(shí)要用＆號，以表示傳遞的是指針：

#include

void AddFive(int* Number)

{

*Number = *Number + 5;

}

void main()

{

int nMyNumber = 18;

cout 七．我眼中的指針--學(xué)習(xí)指針不可少的好文章

我眼中的指針--學(xué)習(xí)指針不可少的好文章

為初學(xué)者服務(wù)。這是我的帖子的宗旨。我也是個(gè)初學(xué)者（強(qiáng)調(diào)了無數(shù)遍了），我以我的理解把初學(xué)者覺得難懂的東西用淺顯的語言寫出來。由于小學(xué)時(shí)語文沒學(xué)好，所以竭盡全力也未必能達(dá)到這個(gè)目的。盡力而為吧。

指針是c和c++中的難點(diǎn)和重點(diǎn)。我只精通dos下的basic。c語言的其它各種特性，在basic中都有類似的東西。只有指針，是baisc所不具備的。指針是c的靈魂。

我不想重復(fù)大多數(shù)書上說得很清楚的東西，我只是把我看過的書中說得不清楚或沒有說，而我又覺得我理解得有點(diǎn)道理的東西寫出來。我的目的是：

1。通過寫這些東西，把我腦袋中關(guān)于c的模糊的知識清晰化。2。給初學(xué)者們一點(diǎn)提示。

3。賺幾個(gè)經(jīng)驗(yàn)值。（因?yàn)橘N這些東西沒有灌水之嫌啊）

第一章。指針的概念

指針是一個(gè)特殊的變量，它里面存儲的數(shù)值被解釋成為內(nèi)存里的一個(gè)地址。要搞清一個(gè)指針需要搞清指針的四方面的內(nèi)容：指針的類型，指針?biāo)赶虻念愋停羔樀闹祷蛘呓兄羔標(biāo)赶虻膬?nèi)存區(qū)，還有指針本身所占據(jù)的內(nèi)存區(qū)。讓我們分別說明。先聲明幾個(gè)指針放著做例子： 例一：(1)int *ptr;(2)char *ptr;(3)int **ptr;(4)int(*ptr)[3];(5)int *(*ptr)[4];如果看不懂后幾個(gè)例子的話，請參閱我前段時(shí)間貼出的文?lt;<如何理解c和c++的復(fù)雜類型聲明>>。

1。指針的類型。

從語法的角度看，你只要把指針聲明語句里的指針名字去掉，剩下的部分就是這個(gè)指針的類型。這是指針本身所具有的類型。讓我們看看例一中各個(gè)指針的類型：(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。指針?biāo)赶虻念愋汀?/p>

當(dāng)你通過指針來訪問指針?biāo)赶虻膬?nèi)存區(qū)時(shí)，指針?biāo)赶虻念愋蜎Q定了編譯器將把那片內(nèi)存區(qū)里的內(nèi)容當(dāng)做什么來看待。從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符 * 去掉，剩下的就是指針?biāo)赶虻念愋汀＠纾?/p>

(1)int *ptr;//指針?biāo)赶虻念愋褪莍nt(2)char *ptr;//指針?biāo)赶虻牡念愋褪莄har(3)int **ptr;//指針?biāo)赶虻牡念愋褪?int *(4)int(*ptr)[3];//指針?biāo)赶虻牡念愋褪?int()[3](5)int *(*ptr)[4];//指針?biāo)赶虻牡念愋褪?int *()[4] 在指針的算術(shù)運(yùn)算中，指針?biāo)赶虻念愋陀泻艽蟮淖饔谩Ｖ羔樀念愋?即指針本身的類型)和指針?biāo)赶虻念愋褪莾蓚€(gè)概念。當(dāng)你對C越來越熟悉時(shí)，你會(huì)發(fā)現(xiàn)，把與指針攪和在一起的“類型”這個(gè)概念分成“指針的類型”和“指針?biāo)赶虻念愋汀眱蓚€(gè)概念，是精通指針的關(guān)鍵點(diǎn)之一。我看了不少書，發(fā)現(xiàn)有些寫得差的書中，就把指針的這兩個(gè)概念攪在一起了，所以看起書來前后矛盾，越看越糊涂。

3。指針的值，或者叫指針?biāo)赶虻膬?nèi)存區(qū)或地址。

指針的值是指針本身存儲的數(shù)值，這個(gè)值將被編譯器當(dāng)作一個(gè)地址，而不是一個(gè)一般的數(shù)值。在32位程序里，所有類型的指針的值都是一個(gè)32位整數(shù)，因?yàn)?2位程序里內(nèi)存地址全都是32位長。指針?biāo)赶虻膬?nèi)存區(qū)就是從指針的值所代表的那個(gè)內(nèi)存地址開始，長度為sizeof(指針?biāo)赶虻念愋?的一片內(nèi)存區(qū)。以后，我們說一個(gè)指針的值是XX，就相 當(dāng)于說該指針指向了以XX為首地址的一片內(nèi)存區(qū)域；我們說一個(gè)指針指向了某塊內(nèi)存區(qū)域，就相當(dāng)于說該指針的值是這塊內(nèi)存區(qū)域的首地址。

指針?biāo)赶虻膬?nèi)存區(qū)和指針?biāo)赶虻念愋褪莾蓚€(gè)完全不同的概念。在例一中，指針?biāo)赶虻念愋鸵呀?jīng)有了，但由于指針還未初始化，所以它所指向的內(nèi)存區(qū)是不存在的，或者說是無意義的。

以后，每遇到一個(gè)指針，都應(yīng)該問問：這個(gè)指針的類型是什么？指針指向的類型是什么？該指針指向了哪里？ 4。指針本身所占據(jù)的內(nèi)存區(qū)。

指針本身占了多大的內(nèi)存？你只要用函數(shù)sizeof(指針的類型)測一下就知道了。在32位平臺里，指針本身占據(jù)了4個(gè)字節(jié)的長度。指針本身占據(jù)的內(nèi)存這個(gè)概念在判斷一個(gè)指針表達(dá)式是否是左值時(shí)很有用。

第二章。指針的算術(shù)運(yùn)算

指針可以加上或減去一個(gè)整數(shù)。指針的這種運(yùn)算的意義和通常的數(shù)值的加減運(yùn)算的意義是不一樣的。例如： 例二：

1。char a[20];2。int *ptr=a;......3。ptr++;在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整形變量a。接下來的第3句中，指針ptr被加了1，編譯器是這樣處理的：它把指針ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字節(jié)做單位的，故ptr所指向的地址由原來的變量a的地址向高地址方向增加了4個(gè)字節(jié)。

由于char類型的長度是一個(gè)字節(jié)，所以，原來ptr是指向數(shù)組a的第0號單元開始的四個(gè)字節(jié)，此時(shí)指向了數(shù)組a中從第4號單元開始的四個(gè)字節(jié)。我們可以用一個(gè)指針和一個(gè)循環(huán)來遍歷一個(gè)數(shù)組，看例子： 例三： 例三： int array[20];int *ptr=array;...//此處略去為整型數(shù)組賦值的代碼。...for(i=0;i<20;i++){(*ptr)++;ptr++； } 這個(gè)例子將整型數(shù)組中各個(gè)單元的值加1。由于每次循環(huán)都將

八．指針詳解

第一章。指針的概念

指針是一個(gè)特殊的變量，它里面存儲的數(shù)值被解釋成為內(nèi)存里的一個(gè)地址。

要搞清一個(gè)指針需要搞清指針的四方面的內(nèi)容：指針的類型，指針?biāo)赶虻念愋停羔樀闹祷蛘呓兄羔標(biāo)赶虻膬?nèi)存區(qū)，還有指針本身所占據(jù)的內(nèi)存區(qū)。讓 我們分別說明。先聲明幾個(gè)指針放著做例子： 例一：(1)int*ptr;(2)char*ptr;(3)int**ptr;(4)int(*ptr)[3];(5)int*(*ptr)[4];

1。指針的類型。

從語法的角度看，你只要把指針聲明語句里的指針名字去掉，剩下的部分就是這個(gè)指針的類型。這是指針本身所具有的類型。讓我們看看例一中各個(gè)指針的類型：(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。指針?biāo)赶虻念愋汀?/p>

當(dāng)你通過指針來訪問指針?biāo)赶虻膬?nèi)存區(qū)時(shí)，指針?biāo)赶虻念愋蜎Q定了編譯器將把那片內(nèi)存區(qū)里的內(nèi)容當(dāng)做什么來看待。從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符 *去掉，剩下的就是指針?biāo)赶虻念愋汀＠纾?/p>

(1)int*ptr;//指針?biāo)赶虻念愋褪莍nt(2)char*ptr;//指針?biāo)赶虻牡念愋褪莄har(3)int**ptr;//指針?biāo)赶虻牡念愋褪莍nt*(4)int(*ptr)[3];//指針?biāo)赶虻牡念愋褪莍nt()[3](5)int*(*ptr)[4];//指針?biāo)赶虻牡念愋褪莍nt*()[4] 在指針的算術(shù)運(yùn)算中，指針?biāo)赶虻念愋陀泻艽蟮淖饔谩?/p>

指針的類型(即指針本身的類型)和指針?biāo)赶虻念愋褪莾蓚€(gè)概念。當(dāng)你對C越來越熟悉時(shí)，你會(huì)發(fā)現(xiàn)，把與指針攪和在一起的“類型”這個(gè)概念分成“指針的類型”和“指針?biāo)赶虻念愋汀眱蓚€(gè)概念，是精通指針的關(guān)鍵點(diǎn)之一。我看了不少書，發(fā)現(xiàn)有些寫得差的書中，就把指針的這兩個(gè)概念攪在一起了，所以看起書來前后矛盾，越看越糊涂。

3。指針的值，或者叫指針?biāo)赶虻膬?nèi)存區(qū)或地址。

指針的值是指針本身存儲的數(shù)值，這個(gè)值將被編譯器當(dāng)作一個(gè)地址，而不是一個(gè)一般的數(shù)值。在32位程序里，所有類型的指針的值都是一個(gè)32位整數(shù)，因?yàn)?2位程序里內(nèi)存地址全都是32位長。指針?biāo)赶虻膬?nèi)存區(qū)就是從指針的值所代表的那個(gè)內(nèi)存地址開始，長度為sizeof(指針?biāo)赶虻念愋?的一片內(nèi)存區(qū)。以后，我們說一個(gè)指針的值是XX，就相當(dāng)于說該指針指向了以XX為首地址的一片內(nèi)存區(qū)域；我們說一個(gè)指針指向了某塊內(nèi)存區(qū)域，就相當(dāng)于說該指針的值是這塊內(nèi)存區(qū)域的首地址。指針?biāo)赶虻膬?nèi)存區(qū)和指針?biāo)赶虻念愋褪莾蓚€(gè)完全不同的概念。在例一中，指針?biāo)赶虻念愋鸵呀?jīng)有了，但由于指針還未初始化，所以它所指向的內(nèi)存區(qū) 是不存在的，或者說是無意義的。以后，每遇到一個(gè)指針，都應(yīng)該問問：這個(gè)指針的類型是什么？指針指向的類型是什么？該指針指向了哪里？

4。指針本身所占據(jù)的內(nèi)存區(qū)。

指針本身占了多大的內(nèi)存？你只要用函數(shù)sizeof(指針的類型)測一下就知道了。在32位平臺里，指針本身占據(jù)了4個(gè)字節(jié)的長度。指針本身占據(jù)的內(nèi)存這個(gè)概念在判斷一個(gè)指針表達(dá)式是否是左值時(shí)很有用。第二章。指針的算術(shù)運(yùn)算

指針可以加上或減去一個(gè)整數(shù)。指針的這種運(yùn)算的意義和通常的數(shù)值的加減運(yùn)算的意義是不一樣的。例如： 例二： 1。char a[20];2。int *ptr=a;......3。ptr++;在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整形變量a。接下來的第3句中，指針ptr被加了1，編譯器是這樣處理的：它把指針 ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字節(jié)做單位的，故ptr所指向的地址由原來的變量a的地址向高地址方向增加了4個(gè)字節(jié)。

由于char類型的長度是一個(gè)字節(jié)，所以，原來ptr是指向數(shù)組a的第0號單元開始的四個(gè)字節(jié)，此時(shí)指向了數(shù)組a中從第4號單元開始的四個(gè)字節(jié)。我們可以用一個(gè)指針和一個(gè)循環(huán)來遍歷一個(gè)數(shù)組，看例子： 例三： int array[20];int *ptr=array;...//此處略去為整型數(shù)組賦值的代碼。...for(i=0;i<20;i++){(*ptr)++;ptr++； } 這個(gè)例子將整型數(shù)組中各個(gè)單元的值加1。由于每次循環(huán)都將指針ptr加1，所以每次循環(huán)都能訪問數(shù)組的下一個(gè)單元。再看例子： 例四： 1。char a[20];2。int *ptr=a;......3。ptr+=5;在這個(gè)例子中，ptr被加上了5，編譯器是這樣處理的：將指針ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由于地址的單位是字節(jié)，故現(xiàn)在的ptr所指向的地址比起加5后的ptr所指向的地址來說，向高地址方向移動(dòng)了20個(gè)字節(jié)。在這個(gè)例子中，沒加5前的ptr指向數(shù)組a的第0號單元開始的四個(gè)字節(jié)，加5后，ptr已經(jīng)指向了數(shù)組a的合法范圍之外了。雖然這種情況在應(yīng)用上會(huì)出問題，但在語法上卻是可以的。這也體現(xiàn)出了指針的靈活性。如果上例中，ptr是被減去5，那么處理過程大同小異，只不過ptr的值是被減去5乘sizeof(int)，新的ptr指向的地址將比原來的ptr所指向的地址向低地址方向移動(dòng)了20個(gè)字節(jié)。

總結(jié)一下，一個(gè)指針ptrold加上一個(gè)整數(shù)n后，結(jié)果是一個(gè)新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值增加了n乘sizeof(ptrold所指向的類型)個(gè)字節(jié)。就是說，ptrnew所指向的內(nèi)存區(qū)將比ptrold所指向的內(nèi)存區(qū)向高地址方向移動(dòng)了n乘sizeof(ptrold所指向的類型)個(gè)字節(jié)。一個(gè)指針ptrold減去一個(gè)整數(shù)n后，結(jié)果是一個(gè)新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值減少了n乘sizeof(ptrold所指向的類型)個(gè)字節(jié)，就是說，ptrnew所指向的內(nèi)存區(qū)將比ptrold所指向的內(nèi)存區(qū)向低地址方向移動(dòng)了n乘sizeof(ptrold所指向的類型)個(gè)字節(jié)。

第三章。運(yùn)算符&和* 這里&是取地址運(yùn)算符，*是...書上叫做“間接運(yùn)算符”。&a的運(yùn)算結(jié)果是一個(gè)指針，指針的類型是a的類型加個(gè)*，指針?biāo)赶虻念愋褪莂的類型，指針?biāo)赶虻牡刂仿铮蔷褪莂的地址。*p的運(yùn)算結(jié)果就五花八門了。總之*p的結(jié)果是p所指向的東西，這個(gè)東西有這些特點(diǎn)：它的類型是p指向的類型，它所占用的地址是p所指向的地址。例五： int a=12;int b;int *p;int **ptr;p=&a;//&a的結(jié)果是一個(gè)指針，類型是int*，指向的類型是int，指向的地址是a的地址。

*p=24;//*p的結(jié)果，在這里它的類型是int，它所占用的地址是p所指向的地址，顯然，*p就是變量a。

ptr=&p;//&p的結(jié)果是個(gè)指針，該指針的類型是p的類型加個(gè)*，在這里是int **。該指針?biāo)赶虻念愋褪莗的類型，這里是int*。該指針?biāo)赶虻牡刂肪褪侵羔榩自己的地址。

*ptr=&b;//*ptr是個(gè)指針，&b的結(jié)果也是個(gè)指針，且這兩個(gè)指針的類型和所指向的類型是一樣的，所以用&b來給*ptr賦值就是毫無問題的了。

**ptr=34;//*ptr的結(jié)果是ptr所指向的東西，在這里是一個(gè)指針，對這個(gè)指針再做一次*運(yùn)算，結(jié)果就是一個(gè)int類型的變量。

第四章。指針表達(dá)式。

一個(gè)表達(dá)式的最后結(jié)果如果是一個(gè)指針，那么這個(gè)表達(dá)式就叫指針表達(dá)式。下面是一些指針表達(dá)式的例子： 例六： int a,b;int array[10];int *pa;pa=&a;//&a是一個(gè)指針表達(dá)式。

int**ptr=&pa;//&pa也是一個(gè)指針表達(dá)式。

*ptr=&b;//*ptr和&b都是指針表達(dá)式。

pa=array;pa++;//這也是指針表達(dá)式。例七： char*arr[20];char**parr=arr;//如果把a(bǔ)rr看作指針的話，arr也是指針表達(dá)式 char*str;str=*parr;//*parr是指針表達(dá)式

str=*(parr+1);//*(parr+1)是指針表達(dá)式 str=*(parr+2);//*(parr+2)是指針表達(dá)式

由于指針表達(dá)式的結(jié)果是一個(gè)指針，所以指針表達(dá)式也具有指針?biāo)哂械乃膫€(gè)要素：指針的類型，指針?biāo)赶虻念愋停羔樦赶虻膬?nèi)存區(qū)，指針自身占據(jù)的內(nèi)存。

好了，當(dāng)一個(gè)指針表達(dá)式的結(jié)果指針已經(jīng)明確地具有了指針自身占據(jù)的內(nèi)存的話，這個(gè)指針表達(dá)式就是一個(gè)左值，否則就不是一個(gè)左值。在例七中，&a不是一個(gè)左值，因?yàn)樗€沒有占據(jù)明確的內(nèi)存。*ptr是一個(gè)左值，因?yàn)?ptr這個(gè)指針已經(jīng)占據(jù)了內(nèi)存，其實(shí)*ptr就是指針pa，既然pa已經(jīng)在內(nèi)存中有了自己的位置，那么*ptr當(dāng)然也有了自己的位置。

第五章。數(shù)組和指針的關(guān)系

數(shù)組的數(shù)組名其實(shí)可以看作一個(gè)指針。看下例： 例八：

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);

上例中，一般而言數(shù)組名array代表數(shù)組本身，類型是int [10]，但如果把a(bǔ)rray看做指針的話，它指向數(shù)組的第0個(gè)單元，類型是int*，所指向的類型是數(shù)組單元的類型即int。因此*array等于0就一點(diǎn)也不奇怪了。同理，array+3是一個(gè)指向數(shù)組第3個(gè)單元的指針，所以*(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是一個(gè)三單元的數(shù)組，該數(shù)組的每個(gè)單元都是一個(gè)指針，這些指針各指向一個(gè)字符串。把指針數(shù)組名str當(dāng)作一個(gè)指針的話，它指向數(shù)組的第0號單元，它的類型是char**，它指向的類型是char*。*str也是一個(gè)指針，它的類型是char*，它所指向的類型是char，它指向的地址是字符串“Hello,thisisasample!”的第一個(gè)字符的地址，即''H''的地址。str+1也是一個(gè)指針，它指向數(shù)組的第1號單元，它的類型是char**，它指向的類型是char*。*(str+1)也是一個(gè)指針，它的類型是char*，它所指向的類型是char，它指向“Hi,goodmorning.”的第一個(gè)字符''H''，等等。下面總結(jié)一下數(shù)組的數(shù)組名的問題。聲明了一個(gè)數(shù)組TYPEarray[n]，則數(shù)組名稱array就有了兩重含義：第一，它代表整個(gè)數(shù)組，它的類型是TYPE[n]；第二，它是一個(gè)指針，該指針的類型是TYPE*，該指針指向的類型是TYPE，也就是數(shù)組單元的類型，該指針指向的內(nèi)存區(qū)就是數(shù)組第0號單元，該指針自己占有單獨(dú)的內(nèi)存區(qū)，注意它和數(shù)組第0號單元占據(jù)的內(nèi)存區(qū)是不同的。該指針的值是不能修改的，即類似array++的表達(dá)式是錯(cuò)誤的。在不同的表達(dá)式中數(shù)組名array可以扮演不同的角色。在表達(dá)式sizeof(array)中，數(shù)組名array代表數(shù)組本身，故這時(shí)sizeof函數(shù) 測出的是整個(gè)數(shù)組的大小。在表達(dá)式*array中，array扮演的是指針，因此這個(gè)表達(dá)式的結(jié)果就是數(shù)組第0號單元的值。sizeof(*array)測出的是數(shù)組單元的大小。表達(dá)式array+n（其中n=0，1，2，....。）中，array扮演的是指針，故array+n的結(jié)果是一個(gè)指針，它的類型是TYPE*，它指向的類型是TYPE，它指向數(shù)組第n號單元。故sizeof(array+n)測出的是指針類型的大小。例十： int array[10];int(*ptr)[10];ptr=&array;上例中ptr是一個(gè)指針，它的類型是int(*)[10]，他指向的類型是int[10]，我們用整個(gè)數(shù)組的首地址來初始化它。在語句ptr=&array中，array代表數(shù)組本身。

本節(jié)中提到了函數(shù)sizeof()，那么我來問一問，sizeof(指針名稱)測出的究竟是指針自身類型的大小呢還是指針?biāo)赶虻念愋偷拇笮。看鸢甘乔罢摺＠纾?int(*ptr)[10];則在32位程序中，有： sizeof(int(*)[10])==4 sizeof(int[10])==40 sizeof(ptr)==4 實(shí)際上，sizeof(對象)測出的都是對象自身的類型的大小，而不是別的什么類型的大小。

第六章。指針和結(jié)構(gòu)類型的關(guān)系 可以聲明一個(gè)指向結(jié)構(gòu)類型對象的指針。例十一： struct MyStruct { int a;int b;int c;}MyStruct ss={20,30,40};//聲明了結(jié)構(gòu)對象ss，并把ss的三個(gè)成員初始化為20，30和40。MyStruct*ptr=&ss;//聲明了一個(gè)指向結(jié)構(gòu)對象ss的指針。它的類型是MyStruct*, //它指向的類型是MyStruct。

int *pstr=(int*)&ss;//聲明了一個(gè)指向結(jié)構(gòu)對象ss的指針。但是它的 //類型和它指向的類型和ptr是不同的。

請問怎樣通過指針ptr來訪問ss的三個(gè)成員變量？ 答案： ptr->a;ptr->b;ptr->c;又請問怎樣通過指針pstr來訪問ss的三個(gè)成員變量？ 答案：

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

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

呵呵，雖然我在我的MSVC++6.0上調(diào)式過上述代碼，但是要知道，這樣使用pstr來訪問結(jié)構(gòu)成員是不正規(guī)的，為了說明為什么不正規(guī)，讓我們看看怎樣通過指針來訪問數(shù)組的各個(gè)單元： 例十二：

int array[3]={35,56,37};int*pa=array;通過指針pa訪問數(shù)組array的三個(gè)單元的方法是： *pa;//訪問了第0號單元 *(pa+1);//訪問了第1號單元

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

從格式上看倒是與通過指針訪問結(jié)構(gòu)成員的不正規(guī)方法的格式一樣。所有的C編譯器在排列數(shù)組的單元時(shí)，總是把各個(gè)數(shù)組單元存放在連續(xù)的存儲區(qū)里，單元和單元之間沒有空隙。但在存放結(jié)構(gòu)對象的各個(gè)成員時(shí)，在某種編譯環(huán)境下，可能會(huì)需要字對齊或雙字對齊或者是別的什么對齊，需要在相鄰兩個(gè)成員之間加若干個(gè)“填充字節(jié)”，這就導(dǎo)致各個(gè)成員之間可能會(huì)有若干個(gè)字節(jié)的空隙。所以，在例十二中，即使*pstr訪問到了結(jié)構(gòu)對象ss的第一個(gè)成員變量a，也不能保證*(pstr+1)就一定能訪問到結(jié)構(gòu)成員b。因?yàn)槌蓡Ta和成員b之間可能會(huì)有若干填充字節(jié)，說不定*(pstr+1)就正好訪問到了這些填充字節(jié)呢。這也證明了指針的靈活性。要是你的目的就是想看看各個(gè)結(jié)構(gòu)成員之間到底有沒有填充字節(jié)，嘿，這倒是個(gè)不錯(cuò)的方法。通過指針訪問結(jié)構(gòu)成員的正確方法應(yīng)該是象例十二中使用指針ptr的方法。

第七章。指針和函數(shù)的關(guān)系

可以把一個(gè)指針聲明成為一個(gè)指向函數(shù)的指針。int fun1(char*,int);int(*pfun1)(char*,int);pfun1=fun1;........inta=(*pfun1)(“abcdefg”,7);//通過函數(shù)指針調(diào)用函數(shù)。

可以把指針作為函數(shù)的形參。在函數(shù)調(diào)用語句中，可以用指針表達(dá)式來作為實(shí)參。例十三： int fun(char*);int a;char str[]=“abcdefghijklmn”;a=fun(str);......int fun(char*s){ int num=0;while(*s!= ''