一、數據成員指針 

好了，我們現在需要一種指針，它指向MyStruct中的任一數據成員，那么它應該是這樣的子：

     int MyStruct::* pMV = &MyStruct::value;
     //或
     int MyStruct::* pMK = &MyStruct::key;

   
     這種指針的用途是用于取得結構成員在結構內的地址。我們可以通過該指針來訪問成員數據：

     int value = pMe->*pMV; // 取得pMe的value成員數據。
     int key = me.*pMK; // 取得me的key成員數據。

   
     那么，在什么場合下會使用到成員數據指針呢？
    確實，成員指針本來就不是一種很常用的指針。不過，在某些時候還是很有用處的。我們先來看看下面的一個函數：

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

 這個函數的功能是什么，你能看明白嗎？它的功能就是，給定count個MyStruct結構的指針，計算出給定成員數據的總和。有點拗口對吧？看看下面的程序，你也許就明白了：
     

     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);
     //計算10個MyStruct結構的value成員的總和： sum_value 值 為 110     (2+4+6+8+ +20)
     int sum_key = sum(me, &MyStruct::key, 10);

   //計算10個MyStruct結構的key成員的總和：   sum_key 值 為 100       (1+3+5+7+ +19)

     也許，你覺得用常規指針也可以做到，而且更易懂。Ok，沒問題：

     int sum(MyStruct* objs, int count)
     {
      int result = 0;
      for(int i = 0; i < count; ++i)
       result += objs[i].value;
      return result;
     }

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

二、使用動態分配防止局部變量自動刪掉

試一下，你能找出下面這段程序的錯誤嗎？
　　#include <iostream.h>
　　int *pPointer;
　　void SomeFunction();
　　{
　　int nNumber;
　　nNumber = 25;　　
　　//讓指針指向nNumber:
　　pPointer = &nNumber;
　　}
　　
　　void main()
　　{
　　SomeFunction(); //為pPointer賦值　　
　　//為什么這里失敗了?為什么沒有得到25　　
　　cout<<"Value of *pPointer: "<<*pPointer<<endl;
　　}
　　這段程序先調用了SomeFunction函數，創建了個叫nNumber的變量，接著讓指針pPointer指向了它。可是問題出在哪兒呢？當函數結束后，nNumber被刪掉了，
　　因為這一個局部變量。局部變量在定義它的函數執行完后都會被系統自動刪掉。也就是說當SomeFunction 函數返回主函數main()時，這個變量已經被刪掉，但pPointer還指著變量曾經用過的但現在已不屬于這個程序的區域。如果你還不明白，你可以再讀讀這個程序，注意它的局部變量和全局變量，這些概念都非常重要。
　　但這個問題怎么解決呢？答案是動態分配技術。注意這在C和C++中是不同的。由于大多數程序員都是用C++，所以我用到的是C++中常用的稱謂。
　　　動態分配　　
　　動態分配是指針的關鍵技術。它是用來在不必定義變量的情況下分配內存和讓指針去指向它們。盡管這么說可能會讓你迷惑，其實它真的很簡單。下面的代碼就是一個為一個整型數據分配內存的例子：　　
　　int *pNumber;
　　pNumber = new int;　　
　　第一行聲明一個指針pNumber。第二行為一個整型數據分配一個內存空間，并讓pNumber指向這個新內存空間。下面是一個新例，這一次是用double雙精型：　　
　　double *pDouble;
　　pDouble = new double;　　
　　這種格式是一個規則，這樣寫你是不會錯的。　　
　　但動態分配又和前面的例子有什么不同呢？就是在函數返回或執行完畢時，你分配的這塊內存區域是不會被刪除的所以我們現在可以用動態分配重寫上面的程序：　　
　　#include <iostream.h>　　
　　int *pPointer;　　
　　void SomeFunction()
　　{　　// 讓指針指向一個新的整型
　　　pPointer = new int;
　　*pPointer = 25;
　　}　　
　　void main()
　　{
　　SomeFunction(); // 為pPointer賦值　　
　　cout<<"Value of *pPointer: "<<*pPointer<<endl;
　　}
　　通讀這個程序，編譯并運行它，務必理解它是怎樣工作的。當SomeFunction調用時，它分配了一個內存，并讓pPointer指向它。這一次，當函數返回時，新的內存區域被保留下來，所以pPointer始終指著有用的信息，這是因為了動態分配。但是你再仔細讀讀上面這個程序，雖然它得到了正確結果，可仍有一個嚴重的錯誤。
　　分配了內存，別忘了回收
　　太復雜了，怎么會還有嚴重的錯誤！其實要改正并不難。問題是：你動態地分配了一個內存空間，可它絕不會被自動刪除。也就是說，這塊內存空間會一直存在，直到你告訴電腦你已經使用完了。可結果是，你并沒有告訴電腦你已不再需要這塊內存空間了，所以它會繼續占據著內存空間造成浪費，甚至你的程序運行完畢，其它程序運行時它還存在。當這樣的問題積累到一定程度，最終將導致系統崩潰。所以這是很重要的，在你用完它以后，請釋放它的空間，如：　　
　　delete pPointer;　　
　　這樣就差不多了，你不得不小心。在這你終止了一個有效的指針（一個確實指向某個內存的指針）。下面的程序，它不會浪費任何的內存：　　
　　#include <iostream.h>　　
　　int *pPointer;　　
　　void SomeFunction()
　　{　　// 讓指針指向一個新的整型
　　pPointer = new int;
　　*pPointer = 25;
　　}　　
　　void main()
　　{
　　SomeFunction(); //為pPointer賦值
　　cout<<"Value of *pPointer: "<<*pPointer<<endl;
　　delete pPointer;
　　}　　
　　只有一行與前一個程序不同，但就是這最后一行十分地重要。如果你不刪除它，你就會制造一起“內存漏洞”，而讓內存逐漸地泄漏。(譯者:假如在程序中調用了兩次SomeFunction，你又該如何修改這個程序呢？請讀者自己思考)

三、一級指針變量與一維數組的關系

int *p   與 int q[10]         

數組名是指針（地址）常量

p=q;   p+i 是q[i]的地址

數組元素的表示方法:下標法和指針法，即若p=q, 則p[i] Û q[i] Û *(p+i) Û *(q+i)

形參數組實質上是指針變量，即int q[ ] Û int *q

在定義指針變量（不是形參）時，不能把int *p 寫成int p[];

系統只給p分配能保存一個指針值的內存區(一般2字節）；而給q分配2*10字節的內存區

四、指針與二維數組

1）對二維數組 int a[3][4],有

a-----二維數組的首地址，即第0行的首地址

a+i-----第i行的首地址

a[i] Û *(a+i)------第i行第0列的元素地址

a[i]+j Û *(a+i)+j -----第i行第j列的元素地址

*(a[i]+j) Û *(*(a+i)+j) Û a[i][j]

a+i=a[i]=*(a+i) =&a[i][0], 值相等，含義不同

a+i   表示第i行首地址，指向行

a[i] Û *(a+i) Û &a[i][0]，表示第i行第0列元素地址，指向列

2）二維數組與指向一維數組的指針變量的關系

如有：   int a[5][10]，(*p)[10];   p = a ;

系統給數組a分配2*5*10個字節的內存區。

系統只給變量p分配能保存一個指針值的內存區(2字節)；

數組名a的值是一個指向有10個元素的一維數組的指針常量;

p=a+i 使 p指向二維數組的第i行;

*(*(p+i)+j) Û a[i][j] ;

二維數組形參實際上是一個指向一維數組的指針變量，即: fun(int x[ ][10]) Û fun(int (*x)[10])在函數fun中兩者都可以有x++;x=x+2;等操作！但在變量定義(不是形參）時，兩者不等價;

3）指針數組與二級指針的關系

int **p   與 int *q[10]        

系統只給p分配能保存一個指針值的內存區；而給q分配10個內存區，每個內存區均可保存一個指針值 ；

指針數組名是二級指針常量；

p=q;   p+i 是q[i]的地址；

指針數組作形參，int *q[ ]與int **q完全等價；但作為變量定義兩者不同。

五、指針與字符串

1）字符指針變量與字符數組的分別

char *cp;    與    char str[20];

字符數組str由若干元素組成，每個元素放一個字符；而指針變量cp中只能存放一個地址值。

char str[20];     str= "I love China!";    (´)

char   *cp;         cp= "I love China!";    (ü)

str是地址常量；cp是地址變量。

cp接受鍵入字符串時,必須先開辟存儲空間。

六、指向函數的指針變量

定義形式： 數據類型 (*指針變量名)();如 int   (*p)( );

main()

{ int max(int ,int), (*p)();

   int a,b,c;

   p=max;

   scanf("%d,%d",&a,&b);

   c=(*p)(a,b);

   printf("a=%d,b=%d,max=%d\n",a,b,c);

}

int max(int x,int y)

{ int z;

   if(x>y) z=x;

   else     z=y;

   return(z);

}