通常指針變量的使用是：先定義指針變量，后給指針變量賦值，最后引用指針變量。現說明如下：
　　（1）定義指針變量
　　在變量定義語句int *p, *p1, *q; 中用 * 定義的變量均為指針變量。因此該語句定義了名為p、p1與q三個整型指針變量。因為指針變量用于存放變量地址，而地址通常為4字節，所以指針變量的長度均為4個字節。
　　（2）指針變量賦值
　　指針變量定義后其值為隨機數，若此隨機數為系統區的地址，則對該指針變量所指系統區某存儲單元進行賦值運算，將改變系統區該單元中內容，可能導致系統的崩潰。所以，指針變量定義后必須賦某個變量的地址或0。
　　從上面例子可以看出，給指針變量賦初值有三種情況：
　　第一種情況是用取地址運算符"&"將變量地址賦給指針變量。如：p=&a；
　　第二種情況是將一個指針變量中的地址賦給另一個指針變量，如：p1=p；
　　第三種情況是給指針變量賦空值0，如q=0；表示該指針變量不指向任何變量。
　　經過賦值后，使指針變量p、p1指向變量a，q不指向任何單元，如圖7.2所示。
　　（3）指針變量的引用
　　指針變量的引用是通過指針運算符"*"實現。在上例中，*p與*p1均表示變量a，因此，第一個輸出語句 cout<<*p 被執行后，輸出的是變量a的內容100。而賦值語句 *p1=200；是通過指針變量p1間接的將數據200賦給變量a，因此，第二個輸出語句中，a 、*p、 *p1同為賦值后變量a的內容200。
　　（4）指針變量初始化
　　指針變量可以象普通變量一樣，在定義指針變量時賦初值，如上例中，定義指針變量p的語句可寫成：int *p=&a; 

7.1.3 指針變量的運算


　　指針變量的運算有三種：賦值運算、關系運算與算術運算。
　　1．指針變量賦值運算
　　指針變量賦值運算就是將變量的地址賦給指針變量，上節內容已介紹過，現再舉一例加深讀者對指針變量賦值運算的理解。
　　【例7.2】定義三個整型變量a1、a2、a3，用指針變量完成a3=a1+a2的操作。再定義兩個實型變量b1、b2，用指針變量完成b1+b2的操作。
　# include <iostream.h>
　void main (void)
　{ int a1=1,a2=2,a3;
　　int *p1,*p2,*p3;
　　float b1=12.5,b2=25.5;
　　float *fp1,*fp2;
　　p1=&a1;
　　p2=&a2;
　　p3=&a3;
　　*p3= * p1 + *p2;
　　fp1=&b1;
　　fp2=&b2;
　　cout<<" *p1="<<*p1<<'\t'<<" *p2="<<*p2<<'\t' <<"*p1+*p2="<<*p3<<'\n';
　　cout<<"a1="<<a1<<'\t'<<" a2="<<a2<<'\t' <<"a1+a2="<<a3<<'\n';
　　cout<<"b1=" <<*fp1<<'\t'<<" b2="<<*fp2<<'\t'<<"b1+b2="<<*fp1+*fp2<<'\n';
　}
　

　　程序執行后，輸出：
　　*p1=1 *p2=2 *p1+ *p2=3
　　a1=1 a2=2 a1+a2=3
　　b1=12.5 b2=25.5 b1+b2=38
　　在此例中，經過指針變量賦值運算后，整型指針變量p1、p2、p3分別指向變量a1、a2、a3，因此，*p1=a1，*p2=a2，*p3=a3。所以，*p3= * p1 + *p2 操作就是a3=a1+a2 操作。如圖7.3(a)所示。

    2．指針變量的算術運算


　　指針變量的算術運算主要有指針變量的自加、自減、加n和減n操作。
　　（1）指針變量自加運算
　　指令格式：<指針變量>++;
　　指針變量自加運算并不是將指針變量值加1的運算，而是將指針變量指向下一個元素的運算。當計算機執行 <指針變量>++ 指令后，指針變量實際增加值為指針變量類型字節數，即：<指針變量>=<指針變量>+sizeof(<指針變量類型>)。假設數組a的首地址為1000，如圖7.4所示。

int *p=&a[0]; //p=1000，指向a[0]元素
　　p++; 
　　第一條語句將數組a的首地址1000賦給指針變量p，使p=1000。第二條語句使p作自加運算：
　　p=p+sizeof(int)=p+4=1004，使p指向下一個元素a[1] 。

   （2）指針變量自減運算
　　指令格式：<指針變量>――;
　　指針變量的自減運算是將指針變量指向上一元素的運算。當計算機執行 <指針變量>―― 指令后，指針變量實際減少為指針變量類型字節數，即：
　　<指針變量>=<指針變量>―sizeof(<指針變量類型>)
　　自加運算和自減運算既可后置，也可前置。
　　（3）指針變量加n運算
　　指令格式：<指針變量>=<指針變量>+n;
　　指針變量的加n運算是將指針變量指向下n個元素的運算。當計算機執行 <指針變量>+ n 指令后，指針變量實際增加值為指針變量類型字節數乘以n，即：
<指針變量>=<指針變量>+sizeof(<指針變量類型>)*n
　　（4）指針變量減n運算
　　指令格式：<指針變量>=<指針變量>―n;
　　指針變量的減n運算是將指針變量指向上n個元素的運算。當計算機執行 <指針變量>― n 指令后，指針變量實際減少值為指針變量類型字節數乘以n，即：
　　<指針變量>=<指針變量>―sizeof(<指針變量類型>)*n
【例7.3】指針變量的自加、自減、加n和減n運算。假設數組a的首地址為1000，如圖7.4所示。


　# include <iostream.h>
　void main( void)
　{ int a[5]={0,1,2,3,4};
　　int *p;
　　p=&a[0]; //p指向a[0]，p=1000
　　p++ ; //p指向下一個元素a[1]，p=1004
　　cout<< *p<<'\t'; //輸出a[1]的內容1。
　　p=p+3; //p指向下3個元素a[4]，p=1016 
　　cout<< *p<<'\t'; //輸出a[4]的內容4。
　　p――; //p指向上一個元素a[3]，p=1012
　　cout<< *p<<'\t'; //輸出a[3]的內容3。
　　p=p―3; //p指向上3個元素a[0],p=1000
　　cout<< *p<<'\t'; //輸出a[0]的內容0。
　}
　　程序執行后輸出：
　　1 4 3 0
　　從上例可以看出，通過對指針變量的加減算術運算，可以達到移動指針變量指向下n個元素單元或向上n個元素單元的目的。

3．指針變量的關系運算
　　指針變量的關系運算是指針變量值的大小比較，即對兩個指針變量內的地址進行比較，主要用于對數組元素的判斷。


　　【例7.4】用指針變量求一維實型數組元素和，并輸出數組每個元素的值及數組和。
　# include <iostream.h>
　void main( void )
　{ int a[5]={1,2,3,4,5};
　　int *p,*p1;
　　p1=&a[4]+1;
　　for (p=&a[0];p<p1;p++) 
　　cout <<*p<<'\t';
　　int sum=0;
　　p=&a[0];
　　while (p!=p1) sum+=*p++;
　　cout <<"\n sum="<<sum<<endl;
　}
　　執行程序后：輸出：
　　1 2 3 4 5 
　　sum=15
　　程序中首先將數組尾地址+1賦給p1，如圖7.4所示。在for 語句中，指針變量p為循環變量，數組首地址&a[0]賦給p。循環時先將循環控制變量p與p1中地址比較，若p<p1，則以*p方式輸出數組元素a[i]的值，并將p自加指向下一個元素。此循環直到p≥p1為止。
　　在while語句中，仍用p作為循環控制變量，當p!=p1時，用sum=sum+*p;語句將數組元素值累加到sum中去，同時用 p++語句使指針變量p指向下一個元素，循環直到p=p1為止，最后輸出數組元素之和。

4．指針運算符的混合運算與優先級


　　（1）指針運算符* 與取地址運算符&的優先級相同，按自右向左的方向結合。
　　設有變量定義語句： int a, *p=&a; 
　　則表達式：&*p 的求值順序為先"*"后"&"，即& (*p)=&a=p 。
　　而表達式：*&a 的求值順序為先"&"后"*"，即* (&a)=*p=a 。
　　（2）"++"、"――"、"*"、"&"的優先級相同，按自右向左方向結合。下面結合例子加以說明。設有變量定義語句：
　　int a[4]={100,200,300,400},b;
　　int * p=&a[0]; 
　　為了敘述方便，假設系統給數組a分配的首地址為1000，如圖7.4所示。
　　① b=*p++; 
　　按自右向左結合的原則，表達式 *p++ 求值序順為先"++"后"*"，即：*(p++)。由于"++"在p之后為后置++運算符，所以表達式的實際操作是先取*p值，后進行p++的自加操作。即賦值表達式 b=*p++; 等同于下面兩條語句： 
　　b=*p; // b=*p=a[0]=100
　　p++; //p=p+sizeof(int)= 1004
　　最后運算的結果為b=100,p=1004指向a[1]。
　　② b=*++p; 
　　按自右向左結合的原則，表達式 *++p 求值順序為先"++"后"*"，即：*(++p)。由于++在p之前為前置++運算符，所以表達式的實際操作是進行++p的自加操作，后取*p值。即賦值表達式 b=*++p; 等同于下面兩條語句： 
　　++p; //p=p+sizeof(int)= 1008，指向a[2]
　　b=*p; // b=*p=a[2]=300
　　最后運算的結果為b=300,p=1008指向a[2]。

③ b=(*p)++; 
　　由于括號內優先運算，所以表達式先取出*p（即a[2]）的值并賦給b，然后將*p的值即a[2]內容加1。所以表達式等同于下面兩條語句：
　　b=*p; //b=a[2]=300 
　　a[2]++ ; // a[2]=300+1=301
　　④ b=*(p++); 
　　由①可知，該表達式等同于*p++，運算結果為：
　　b=*p; //b=a[2]=301
　　p++; // p=p+sizeof(int)=1012，指向a[3]
　　⑤ b=++*p ;
　　該表達式先進行"*"運算，再進行"++"運算，即先取出*p的值，再將該值加1。因此表達式實際進行了如下運算：b=++(*p)=++a[3]=400+1=401; p仍指向a[3]不變。
　　將上述討論中各語句匯總為例題如下：


 

　　【例7.5】指針運算符"*"、"&"、"++"優先級與結合律示例。
　# include <iostream.h>
　main()
　{ int a[4]={100,200,300,400},b;
　　int *p=&a[0];
　　cout<<'\t'<<"p="<<p<<endl;
　　b=*p++;
　　cout<<"b="<<b<<'\t'<<"p="<<p<<endl;
　　b=*++p;
　　cout<<"b="<<b<<'\t'<<"p="<<p<<endl;
　　b=(*p)++;
　　cout<<"b="<<b<<'\t'<<"p="<<p<<endl;
　　b=*(p++);
　　cout<<"b="<<b<<'\t'<<"p="<<p<<endl;
　　b=++*p;
　　cout<<"b="<<b<<'\t'<<"p="<<p<<endl;
　　}
　　運行結果為：
　　p=0x0065FDE8
　　b=100 p=0x0065FDEC
　　b=300 p=0x0065FDF0
　　b=300 p=0x0065FDF0
　　b=301 p=0x0065FDF4
　　b=401 p=0x0065FDF4
　　說明：在定義數組時，數據a的地址是由操作系統存儲管理動態分配的，因此，數組a的地址是不確定的，每次運行的結果都可能會不同。一般用十六進制數表示。本例中系統為數組a分配的首地址為0x0065FDE8。而在圖7.4中所假設的地址1000~1016完全是為了便于讀者理解。