《程序設計與C語言》課件第7章

第7章指針7.1指針的概念及定義7.2指針運算7.3指針與數(shù)組7.4指針與函數(shù)7.5多級指針習題75我們已經(jīng)知道，在使用一個變量以前必須先定義。定義的作用就是讓編譯器為該變量在內(nèi)存中分配一個空間來作為變量的工作場所。而內(nèi)存是以字節(jié)為單位組織的，每個字節(jié)都有固定的編號(正如一座大樓中每個房間都有個房間號一樣)，這些編號就稱為地址。例如，定義整型變量y：

inty;編譯器就在內(nèi)存中為它安排2字節(jié)的空間。設開始字節(jié)的地址為500000，對y進行賦值操作：

y=5;結果為：500000y7.1指針的概念及定義當要訪問y時，直接到內(nèi)存地址為500000的地方，讀寫其中的內(nèi)容即可，這樣的訪問稱為直接訪問。我們可以把y的地址放到另一個變量中保存起來，若設該變量為yptr，而它在內(nèi)存中也有個地址，比如為400000，則它們之間的關系如下：我們用箭頭指向來簡單地表示這種關系：讀作“yptr指向y”。500000400000y5500000yyptr5y如果要通過yptr訪問y的內(nèi)容，就必須先從yptr中取出y的地址，再按這個地址找到y(tǒng)的所在地，然后對其內(nèi)容進行操作。這樣的訪問稱為間接訪問。正如要到一座大樓某房間取放東西，應先到傳達室了解該房間的具體位置，取出鑰匙后再到該房間一樣。上面的yptr稱為指針變量。像其他變量一樣，在使用指針變量之前必須先定義。指針變量定義的一般格式為：

〈類型標識符〉*〈指針變量名〉例如

inty,*yptr;即聲明了一個整數(shù)型的指針變量yptr，可讀為：“yptr是一個指向整數(shù)值的指針”或“yptr指向整數(shù)類型值”。7.2指針運算7.2.1指針運算符與指針運算有關的運算符有兩個：&和*。它們都是單目運算符，其優(yōu)先級僅次于()和［］，結合性為從右向左。運算符&稱為地址運算符，它只能作用在變量上，而不能作用在常量或表達式上。它返回的是該變量在內(nèi)存中的地址。例如：

int*countptr,count=7;則語句

countptr=&count;就把變量count的地址賦給了指針變量countptr。這時可以說變量countptr指向了變量count，其關系如下所示：countptr7count運算符“*”稱為間接引用運算符或復引用運算符。它作用在一個指針變量上，返回這個指針所指向的對象的值，因此被稱為間接引用運算符。countptr所指對象為count，所以*countptr即為count。例如語句：

printf(″%d″,*countptr)；即輸出count的當前值7。如果一個指針變量已指向某個變量，即已具有一個地址值，那么若把&和*這兩個運算符以任意次序連續(xù)地作用在該指針變量上，則會得到同樣的結果，即同一個地址，這稱為&和*對指針變量的互補性。下面的程序演示了指針運算符的用法。格式說明符“%p”是指以十六進制的形式輸出內(nèi)存地址。

【例7-1】指針運算符的用法。＃include<stdio.h>main(){inta=7,*aptr=&a;printf(″Theaddressofais%p＼nThevalueofaptris:%p＼n″,&a,aptr)；printf(″Thevalueofais:%d＼nThevalueof*aptris:%d＼n″,a,*aptr)；printf(″Provingthat*and&arecomplementeachother＼n″)；printf(″&*aptr=%p＼n*&aptr=%p＼n″,&*aptr,*&aptr)；return0;}運行輸出：

Theaddressofais:FFF4Thevalueofaptris:FFF4Thevalueofais:7Thevalueof*aptris:7Provingthat*and&arecomplementeachother&*aptr=FFF4*&aptr=FFF4這里，變量a和aptr都是在定義時賦初值的。它們的先后次序很重要，應該先定義a，后定義aptr,因為aptr用到了a的地址。如將其位置倒置將會出現(xiàn)錯誤。程序驗證了變量a的地址確實賦給了指針變量aptr，并且對指針變量aptr來說，其值與&和*作用的先后次序無關，都是a的地址，即

&*aptr=*&aptr=&a可以這樣來分析這種關系：

·&*aptr=&(*aptr)=&a(根據(jù)運算符的右結合規(guī)則及*aptr=a得到)

·對*&aptr可以這樣來分析：設又有一個指針變量paptr，它里面放的是指針變量aptr的地址(paptr稱為二級指針)，即paptr=&aptr,則*paptr為它所指向的對象aptr,即a的地址。所以有： *&aptr=*(&aptr)=*paptr=aptr=&a表示為：paptraptra一個指針變量除了可以賦給它地址值以外，還可以向它賦0或NULL。具有NULL值的指針不指向任何對象，這在動態(tài)數(shù)據(jù)操作中非常有用。NULL是在<stdio.h>頭文件中定義的符號常量。把一個指針變量賦值為0或NULL是等價的，但用NULL更好些。一般情況下，指針變量是不能接收整數(shù)值的。例如：

int*aptr；

aptr=7;則會產(chǎn)生錯誤。但整數(shù)0是惟一的例外。aptr=0是正確的。說明：

①指針變量有類型。相同類型的指針變量之間可以互相賦值，不同類型的指針變量之間不能互相賦值；指針變量只能接收同類型的變量地址，不能接收不同類型的變量地址。例如：

inta,*aptr1,*aptr2;floatb,*bptr;則

aptr1=&a;aptr2=aptr1;bptr=&b;都是正確的。但

bptr=&a;bptr=aptr1;都是錯誤的。②對于普通變量，&和*運算符沒有互補性。例如：

inta=5;則只能寫成*&a,而不能寫成&*a，因為*只能作用于地址，而不能作用于普通變量。③指針變量必須被正確地賦值之后才能使用。當指針的指向未定時，若用指針變量輸出，例如語句：

inti,*p;printf(″%d″,*p)；將會輸出一個無意義的結果，因為p未指向一個具體的地方。在指針指向未定的情況下，用指針變量輸入，例如語句：

scanf(″%d″,p);或 *p=5;都是被禁止的，因為指針變量p隨機地指向內(nèi)存中的某個地址，而在這個內(nèi)存區(qū)域中可能會有重要的內(nèi)容，而輸入語句又是破壞性的，這樣很可能會破壞掉系統(tǒng)的重要數(shù)據(jù)，引起嚴重的不良后果。7.2.2指針作函數(shù)參數(shù)我們已經(jīng)知道，C語言中函數(shù)調(diào)用時的參數(shù)傳遞是值傳遞，即“傳值調(diào)用”，也就是把實參變量的拷貝傳給形參后，實參和形參之間就再沒有其他關系了，函數(shù)中對形參的處理都和實參無關。正因為如此，想用函數(shù)調(diào)用來改變實參變量的值，那是不可能的，比如前面已描述過的交換兩個變量值的情況。但是在學了指針變量之后，這個問題就迎刃而解了，也就是說，使用指針變量，就可以通過函數(shù)調(diào)用來對實參變量進行操作。具體解決辦法是，把函數(shù)的形參定義成指針類型，而將實參定義為變量的地址，實參變量和形參指針的類型相一致，這樣就可使形參和實參都指向內(nèi)存中的同一塊區(qū)域，則函數(shù)中對形參的處理也就是對實參的處理。這稱為函數(shù)的“傳引用調(diào)用”。

【例7-2】通過函數(shù)調(diào)用，交換兩個變量的值。＃include<stdio.h>voidexchange(int*,int*);main(){inta=5,b=8;printf(″a=%d,b=%d＼n″,a,b);exchange(&a,&b);printf(″a=%d,b=%d＼n″,a,b);return0;}voidexchange(int*p1,int*p2)

{intn;n=*p1;*p1=*p2;*p2=n;

}運行輸出：

a=5,b=8a=8,b=5函數(shù)exchange的兩個參數(shù)都是整型指針，而主調(diào)函數(shù)用兩個整型變量的地址&a、&b作為實參來調(diào)用函數(shù)，這相當于把&a賦給p1,把&b賦給p2，于是p1就指向a，p2就指向b。在函數(shù)中交換p1和p2所指的對象，即交換了a和b的值。調(diào)用過程如圖7-1所示。①n=*p1;②*p1=*p2;③*p2=n;圖7-1例7-2程序中函數(shù)的調(diào)用過程示意圖注意：函數(shù)exchange不能寫成如下形式：

voidexchange(int*p1,int*p2){int*p;*p=*p1;*p1=*p2;*p2=*p;}這里的問題就是前面已指出的，若一個指針變量未確切地指向某個變量，則不能對其進行輸入/輸出操作。這里的p未指向任何變量，則賦值*p=*p1很可能破壞它所指向的那個地方的數(shù)據(jù)，因此這種用法是被禁止的。同樣，exchange也不能寫成下面的形式：

voidexchange(int*p1,int*p2){int*p;p=p1;p1=p2;p2=p;}函數(shù)中交換了兩個指針變量，調(diào)用這樣的函數(shù)能達到交換兩個普通變量的目的嗎?看一下圖7-2就清楚了。①p=p1;②p1=p2;③p2=p;圖7-2修改后的例7-2程序中函數(shù)的調(diào)用過程示意圖從圖7-2可見，函數(shù)調(diào)用后，變量a、b的值并未發(fā)生交換。這是因為地址的傳送仍然是值的傳送，在把a、b的地址傳給p1、p2之后，函數(shù)中對p1、p2的處理已和&a、&b無關了，即a、b地址并未改變，也未涉及到對a、b的操作，所以函數(shù)調(diào)用和a、b本身沒有關系。

【例7-3】傳值調(diào)用和傳引用調(diào)用的差別。＃include<stdio.h>intval(int);intref(int*);main(){intn=5,m;printf(″n=%d＼n″,n);[HJ]m=val(n);printf(″m=%d,n=%d＼n″,m,n);n=5;printf(″n=%d″,n);ref(&n);printf(″n=%d＼n″,n);return0;}intval(inti){returni*i*i;}intref(int*p){*p=*p**p**p; return0;}運行輸出：

n=5m=125,n=5n=5n=125下面分別考查這兩個函數(shù)調(diào)用前后，變量n的表現(xiàn)情況。

(1)傳值調(diào)用的val函數(shù)(如圖7-3所示)。在val函數(shù)調(diào)用前，形參i無確定的值，如圖7-3(a)所示；調(diào)用時，i接收實參n的拷貝后，n、i之間即無關聯(lián)，如圖7-3(b)所示；i以n的拷貝值進行計算，如圖7-3(c)所示；返回主函數(shù)，則i又無確定的值，n仍如前，如圖7-3(d)所示。圖7-3val函數(shù)的傳值調(diào)用

(2)傳引用調(diào)用的ref函數(shù)(如圖7-4所示)。

ref函數(shù)調(diào)用前，指針p不確定，如圖7-4(a)所示；調(diào)用函數(shù)ref,將&n賦給p，使p指向n,如圖7-4(b)所示；函數(shù)中對p所指對象(*p)進行計算，則直接影響參數(shù)n,如圖7-4(c)所示。函數(shù)ref中仍然可以通過return語句正常地返回一個值，但它又捎帶地改變了主調(diào)函數(shù)中變量n的值，這稱為傳引用調(diào)用的副作用。有意識地利用傳引用調(diào)用的副作用可以幫助我們解決所需問題，而無意識地使用傳引用調(diào)用的副作用，可能不會得到我們所希望的結果。因此給出如下建議：除非主調(diào)函數(shù)明確要求被調(diào)函數(shù)修改主調(diào)函數(shù)中的參數(shù)變量，則一律用傳值調(diào)用的方式向被調(diào)函數(shù)傳遞參數(shù)。圖7-4ref函數(shù)的傳引用調(diào)用7.2.3最低訪問權原則和const限定符在函數(shù)調(diào)用中，最低訪問權原則是：為了完成指定的任務，總是授予函數(shù)訪問其參數(shù)的足夠的權限，但又不給予更多的權限，夠用即可。用const限定符可以實現(xiàn)最低訪問權原則。用這個原則正確地設計軟件可以大大減少調(diào)試時間和不良的副作用，并使程序易于修改，這對建立良好的軟件工程有很大的意義。

const限定符的作用是通知編譯器禁止對某些特定變量進行修改。用const限定函數(shù)的參數(shù)有六種可能的情況，其中有兩種用于傳值調(diào)用，4種用于傳引用調(diào)用。下面分別介紹這幾種情況。

1.用于傳值調(diào)用

const用于傳值調(diào)用時有兩種情況：對參數(shù)使用const限定和不使用const限定。

(1)不使用const限定參數(shù)時，參數(shù)可以在函數(shù)體中被修改。

【例7-4】打印一維數(shù)組的函數(shù)，用數(shù)組和其大小作參數(shù)。若對反映數(shù)組大小的參數(shù)不加const限定，則可以打印任意個指定個數(shù)的元素。

＃include<stdio.h>voidprinta(int［］,int);main(){inta［6］={1,2,3,4,5,6};printa(a,6);return0;}voidprinta(intb［］,ints){inti;printf(″Outputallelementsofarray:＼n″);for(i=0;i<=s-1;i++)printf(″%3d″,b［i］);printf(″Outputhalfelementsofarray:＼n″);s=s/2;for(i=0;i<=s;i++)printf(″%3d″,b［i］);}運行輸出：

Outputallelementsofarray:123456Outputhalfelementsofarray:1234在函數(shù)中可以對參數(shù)s進行修改(s=s/2)。

(2)使用const限定參數(shù)。仍用例7-4說明，主函數(shù)不加改變，而printa的參數(shù)作如下修改：

voidprinta(int［］，constints)則在函數(shù)體中就不允許出現(xiàn)下面的語句：

s=s/2;因為這樣就修改了用const限定的參數(shù)。

2.用于傳引用調(diào)用

const用于傳引用調(diào)用時有四種不同的情況，如表7-1所示。

(1)指向非常量數(shù)據(jù)的非常量指針，具有最高訪問權。在函數(shù)中既可以修改指針所指的對象，又可以修改指針本身。其使用特征是指針前無const限定。

【例7-5】利用函數(shù)調(diào)用，把小寫字母轉換成大寫字母。＃include<stdio.h>voidltou(char*);main(){chars［］=″string″;printf(″Beforeconverted:%s＼n″,s);ltou(s);printf(″Afterconverted%s＼n″,s);return0;}voidltou(char*p){while(*p!=′＼0′) {if(*p>=′a′&&*p<=′z′) *p-=32; /*修改了指針p所指對象*/ ++p; /*修改了指針p本身*/}}運行輸出：

Beforeconverted:stringAfterconverted:STRING

(2)指向常量數(shù)據(jù)的非常量指針，這時指針可以被修改，但指針所指的對象不能被修改。

【例7-6】逐字符地輸出字符串。＃include<stdio.h>voidprintc(constchar*);main(){chars［］=″China″;puts(″Ｔhestringis:＼n″);printc(s);putchar(′＼n′);return0;}voidprintc(constchar*p){for(;*p!=′＼0′;p++) /*修改了指針p的值*/ putchar(*p);}運行輸出：

Thestringis:China函數(shù)調(diào)用printc(s)是把實參數(shù)組s的首地址(即第一個元素的地址)賦給形參指針p，由putchar函數(shù)輸出p所指對象*p，即第一個字符值，然后修改指針p的值(p++)，使它指向下一個字符。整個過程中p的值在不斷地修改，而p所指的對象*p并沒有被修改。如果對指向常量數(shù)據(jù)的非常量指針所指對象進行修改，則會出現(xiàn)錯誤。

【例7-7】錯誤的指針操作之一。＃include<stdio.h>voidf(constint*);main(){inta=5;f(&a);return0;}voidf(constint*p){*p=20; /*錯誤!試圖修改指針所指對象*/printf(″%d″,*p);}函數(shù)中對指針p所指對象*p的修改會引起編譯錯誤，使程序不能運行下去，這也是對數(shù)據(jù)的一種保護措施。

(3)指向非常量數(shù)據(jù)的常量指針，此時指針指向的對象可以改變，但指針本身不能改變。

【例7-8】錯誤的指針操作二。＃include<stdio.h>main()

{intx=5,y;int*constp=&x;printf(″(*p)++=%d＼n″,(*p)++);p=&y; /*錯誤!試圖修改指針本身*/return0;}編譯時會指出p=&y是個錯誤，這是因為p原來已指向x，現(xiàn)在又想讓它指向y，就是要修改它的值，這是不允許的。但p所指的對象*p可以被修改，因此(*p)++是合法的。

(4)指向常量數(shù)據(jù)的常量指針，具有最少的訪問權。指針本身不能被修改，指針所指的對象也不能被修改。

【例7-9】錯誤的指針操作三。＃include<stdio.h>main()

{intx=5,y;constint*constp=&x;*p=7; /*錯誤!試圖修改指針p所指對象*/p=&y; /*錯誤!試圖修改指針本身*/return0;}7.2.4指針表達式與指針運算指針變量可以用在算術表達式、條件表達式和賦值表達式中，含有指針的表達式可統(tǒng)稱為指針表達式。指針表達式的使用是有條件的，只有在一定的條件下指針表達式才有意義。

1.指針的賦值和算術運算當一個指針指向一個數(shù)組時，可以對指針進行自加(++)，自減(--)，加上一個整數(shù)(+,+=)，減去一個整數(shù)(-,-=)，減去另一個指針等運算。如有語句

intv［10］,*p=&v［0］；

floatu［5］,*pf=&u［0］；則指針p和數(shù)組v發(fā)生關聯(lián)，指針pf和數(shù)組u發(fā)生關聯(lián)。若p如下圖所示：則p接收普通變量v［0］的地址，指向了數(shù)組v的首地址。此時可以對指針進行加運算：

p++;這樣使p指向下一個元素v［１］。若進行運算

p+=3;將使p指向數(shù)組的第四個元素v［３］，即p=&v［3］，此時指針發(fā)生了移動。而如果在p指向v［0］之后，則表達式p+3也指向v［3］，即p+3=&v［3］，于是有*(p+3)=v［３］，但此時p未發(fā)生移動，仍指向v［0］，即p=&v［0］，有*p=v［0］。因此在對指針進行運算時，應注意指針本身是否發(fā)生了移動。至于指針變量加1后移動多少個字節(jié)，是由編譯器根據(jù)元素的類型自動決定的。比如在p指向v［０］的情況下進行p++運算，在內(nèi)存中是由存儲單元3000變到3002，指針移動了兩個字節(jié)。因為一個整型元素在內(nèi)存中占兩個字節(jié)。如果指向第四個元素，則要移到3000+3×2=3006單元處。一般來說，若有p+i運算，則指針移向3000+2*i處。同樣對浮點型指針pf，若pf如下圖所示：則進行pf+i運算后，將使指針pf指向4000+4*i處，移動4*i個字節(jié)。所以對指針進行加運算，在內(nèi)存中是根據(jù)數(shù)組元素的類型來決定該指針移動多少個字節(jié)的。這一工作由編譯器去完成，在程序中可以不做這方面的考慮，只要把指針加上的整數(shù)作為元素個數(shù)來對待就行了。同樣，對指針變量進行減去一個整數(shù)的運算就是把指針向前拉回幾個元素，至于拉回多少個字節(jié)，由編譯器去處理。對指針進行加、減運算的前提條件是指針已指向一個數(shù)組，否則運算是無意義的。如果兩個指針都指向同一個數(shù)組，則它們之間可以進行減運算，其含義是兩個指針指向的對象之間的位置差距。如下圖的p1和p2指針：則有p2-p1=4，說明p2所指元素在p1所指元素后面的第4個元素的地方。

注意：上面指針的相減運算p2-p1=4,也就是&a［6］-&a［2］=4。它表示的是兩個指針(兩個地址)間的相對位置的差別，并不是兩個絕對地址的差別。絕對地址之差是指它們相距字節(jié)數(shù)之差，這就和數(shù)組的類型有關了。對于整型數(shù)組，每個元素占兩個字節(jié)（如TurboC）；對于浮點型數(shù)組，每個元素占4個字節(jié)。絕對地址的表示是在指針(地址)前面加(int)的強制類型轉換。這樣，對整型數(shù)組a來說，有：

(int)p2-(int)p1=(int)&a［6］-(int)&a［2］=8而如果a是浮點型數(shù)組，則有：

(int)p2-(int)p1=(int)&a［6］-(int)&a［2］=16但不管是哪類數(shù)組，p2-p1的值總是4。兩個指針相加是無意義的，不管它們是否指向同一個數(shù)組。

2.指針的比較運算可以用關系運算符比較兩個指針，前提條件也是這兩個指針都指向同一個數(shù)組，否則這種比較是沒有意義的。兩個指針的比較結果反映它們所指向元素的先后次序。指針的比較運算常用來判斷某個指針值是否為NULL。例如：

if(sptr!=NULL)…while(sptr!=NULL)…指針運算常見的錯誤有：

(1)對不指向數(shù)組的指針進行算術運算。

(2)對不指向同一數(shù)組的指針進行相減或比較運算。

(3)指針運算的結果超出了數(shù)組的范圍。比如指針已指向第一個元素時再進行減運算，已指向最后一個元素時再進行加運算，都會出現(xiàn)運行錯誤。這時編譯器可能不指出語法錯誤，但指針所指向的內(nèi)容是錯誤的數(shù)據(jù)。7.3指針與數(shù)組

C語言中，指針與數(shù)組之間有著密切的關系，它們幾乎可以互換使用。數(shù)組可以被認為是一個常量指針，而指針又可以完成數(shù)組下標的操作。數(shù)組的維數(shù)不同，數(shù)組元素的地址表示和用指針處理的方法也不同，因此我們分別加以討論。7.3.1一維數(shù)組和指針

1.一維數(shù)組的地址和指針的關系一維數(shù)組的地址也就是數(shù)組元素的地址，數(shù)組名代表數(shù)組的首地址，也是數(shù)組第一個元素的地址。如：

inta［10］，*p；則a和&a［0］是等價的。指針是存放變量地址的變量，因此可以把數(shù)組元素的地址放入指針中，這可通過賦值語句實現(xiàn)。如

p=&a［０］；或p=a；二者效果相同，都使p指向數(shù)組a的開頭，如圖7-5所示。圖7-5一維數(shù)組的地址和指針的關系…pa對指針變量也可以在定義的時候賦初值，但數(shù)組的定義應放在前頭：

inta［10］,*p=a;如果次序顛倒，則會出現(xiàn)錯誤。

2.一維數(shù)組元素的表示方式數(shù)組名相當于指針，指針又可指向數(shù)組，因此利用數(shù)組名和指針來表示數(shù)組元素可以有多種方式。設

inta［10］,*p=a；

1)數(shù)組下標表示法用數(shù)組名加下標來表示數(shù)組元素，這也是我們常用的方法。如

a［0］表示數(shù)組a的第1個元素；

a［i］表示數(shù)組a的第i+1個元素。

2)“數(shù)組名+偏移量”表示法數(shù)組名也是數(shù)組第1個元素的地址，數(shù)組名加整數(shù)i就是第i+1個元素的地址，對該地址進行復引用*運算，就可得到該元素，因此有：*a=*(a+0)=a［0］*(a+i)=a［i］這是一個基本的關系式，一定要記牢。

3)指針帶下標表示法如果指針已指向一個數(shù)組，那么指針是可以帶下標的，帶下標的指針就相當于數(shù)組元素。如：

p［0］=a［0］

p［i］=a［i］

4)“指針+偏移量”表示法指針加一整數(shù)i，就表示第i+1個元素的地址，再用復引用運算符*就可得到該元素。如：*(p+0)=*p=*a=a［０］*(p+i)=*(a+i)=a［i］

說明：雖然數(shù)組名加下標和指針加下標都能表示數(shù)組元素，但它們還是有根本區(qū)別的：數(shù)組名是常量，而指針是變量，當指向數(shù)組時可以進行加減運算。因*(p-i)=p［-i］，所以指針可以加負下標，表示指向當前元素的前面某個元素。而數(shù)組名就不能有負下標，如a［-i］就是沒有意義的。下面的程序演示了一維數(shù)組元素的這幾種表示方法，表明了它們的一致性。

【例7-10】一維數(shù)組元素的多種表示方法。＃include<stdio.h>main(){inti,offset,a［］={10,20,30,40},*p=a;printf(″Arrayaprintedwithsubscriptnotation:＼n″);for(i=0;i<=3;i++)printf(″a［％d］=%d＼n″,i,a［i］);printf(″Arrayname/offsetnotation:＼n″);for(offset=0,offset<=3;offset++)printf(″*(a+%d)=%d＼n″,offset,*(a+offset));printf(″Pointersubscriptnotation:＼n″);for(i=0;i<=3;i++)printf(″p［%d］=%d＼n″,i,p［i］);printf(″Pointer/offsetnotation:＼n″);for(offset=0;offset<=3;offset++)printf(″*(p+%d)=%d\n″,offset,*(p+offset));p=a+4printf(″Pointerneg_subscriptnotation:(whenp=a+4;)\n″);for(i=4;i>=1;i--)printf(″p［-%d］=%d＼n″,i,p［-i］);return0;}運算輸出：

Arrayaprintedwithsubscriptnotation:a［0］=10a［1］=20a［2］=30a［3］=40Arrayname/offsetnotation:*(a+0)=10*(a+1)=20*(a+2)=30*(a+3)=40Pointersubscriptnotation:p［0］=10p［1］=20p［2］=30p［3］=40Pointer/offsetnotation:*(p+0)=10*(p+1)=20*(p+2)=30*(p+3)=40Pointerneg_subscriptnotation:(whenp=a+4;)p［-4］=10p［-3］=20p［-2］=30p［-1］=40

注意：指針變量的運算及其意義如下：

(1)*(p+1)不等于*(p++)。*(p+1)表示p所指向的元素的下一個元素，而*(p++)表示先求p當前指向的元素，然后移動指針向下一個元素。因自加運算符是右結合的，所以有*(p++)=*p++。

(2)*(p++)不等于*(++p)。*(++p)是先移動指針，再求指針所指對象。

(3)(*p)++是對p所指對象的內(nèi)容加1。

(4)若p=&a［i］，則*(p++)=a［i++］ 先求a［i］，再移向a［i+1］*(p--)=a［i--］ 先求a［i］，再移向a［i-1］*(++p)=a［++i］ 先移向a［i+1］，再求其值*(--p)=a［--i］ 先移向a［i-1］，再求其值

【例7-11】定義并輸入有10個元素的數(shù)組，再以反序輸出。＃include<stdio.h>main(){inti,*p,a［10］;p=a;puts(″Input10integers:＼n″);for(i=0;i<=9;i++)scanf(″%d″,p++);p--;puts(″inverseoutput″);for(i=0,i<=9;i++)printf(″%4d″,*p--);return0;}運行輸出：

Input10integers:12345678910↙

inverseoutput:10987654321輸入時p本身已代表地址，因而不應再加取地址運算符&。每輸入一個數(shù)，指針向下移一個元素位置，10次之后，指針移向數(shù)組后的位置，此處的內(nèi)容是不確定的，不能使用，所以要先進行p--操作使p指向數(shù)組的最后一個元素。*p--是先求*p，再把p向前移動一個位置。

3.數(shù)組和指針作參數(shù)前面我們已講過，數(shù)組可以作參數(shù)，函數(shù)調(diào)用時，實際傳送的是數(shù)組的首地址?，F(xiàn)在我們又學習了指針，并且知道數(shù)組名和指針可以互換使用，因此用函數(shù)調(diào)用處理數(shù)組時，參數(shù)的傳遞形式就更加多種多樣。實參和形參的關系如圖7-6所示，也就是有四種互相搭配的情況：

(1)實參和形參全是數(shù)組名。這種情況在前面已經(jīng)作過介紹，這里不再重復。

(2)實參是數(shù)組名，形參為指針。這時把數(shù)組名賦給指針變量，使該指針指向數(shù)組，函數(shù)中對指針所指對象的處理也就是對實參數(shù)組的處理。圖7-6實參和形參的關系

【例7-12】用簡單排序法對數(shù)組排序。編程思路：簡單排序的思想是把數(shù)組中從第二個元素起的各元素分別和第一個元素比較，若逆序則交換之，一遍之后，最小的元素就放到了第一位。為找最小元素可能會發(fā)生多次的交換。接著按同樣的方法找位置2上的合適元素……這樣的排序效率不高，它的改進形式是選擇排序，我們已經(jīng)介紹過。這里我們把簡單排序操作編成一個函數(shù)，交換兩個元素的操作也用函數(shù)實現(xiàn)。主函數(shù)中的實參用數(shù)組名，被調(diào)函數(shù)中的形參用指針。

＃include<stdio.h>voidsimplesort(int*,constint);main(){inti,a［10］={8,6,7,3,2,9,34,28,57,1};puts(″Beforesort:＼n″);for(i=0;i<=9;i++)printf(″%d″,*(a+i));simplesort(a,10);puts(″Aftersorted:＼n″);for(i=0;i<=9;i++)printf(″%d″,a［i］); putchar(′＼n′);return0; }voidsimplesort(int*p,constints){inti,j,t;voidexchange(int*,int*);for(i=0;i<=s-2;i++)for(j=i+1;j<=s-1;j++)if(p［i］>p［j］)exchange(p+i,p+j);

}voidexchange(int*x1,int*x2){intt;t=*x1;*x1=*x2;*x2=t;}運行輸出：

Beforesort:8673293428571Aftersorted:1236789283457這個程序中有幾點需要注意：函數(shù)simplesort把參數(shù)p聲明為指針變量，這表明要用指針來處理數(shù)組。參數(shù)s用const限定，是為了強制實現(xiàn)最低訪問權原則，因為函數(shù)中不需要修改s的值，如果在排序過程中要改變s的值，則會引起錯誤。主函數(shù)中用數(shù)組名a調(diào)用simplesort函數(shù)，就是把a的首地址賦給形參指針p，函數(shù)中對p的處理也就是對a的處理。函數(shù)中用指針帶下標的方法表示數(shù)組元素，p［i］就是p所指向的第i+1個元素。在函數(shù)simplesort中又調(diào)用了函數(shù)exchange,主調(diào)和被調(diào)函數(shù)所用的參數(shù)都是指針，因為它們的類型相同，可以進行賦值。simplesort中的p+i代表指向第i+1個元素的指針。另外，函數(shù)exchange只在simplesort中被調(diào)用，所以把它的原型說明放到simplesort中，這就保證了除simplesort函數(shù)之外的任何函數(shù)都不能調(diào)用它。這也是強制實現(xiàn)最低訪問權原則的一種情況。在給函數(shù)傳遞參數(shù)時，不僅傳遞數(shù)組名，而且也傳遞數(shù)組的大小，這樣可以使函數(shù)更具通用性，即可對任何大小的數(shù)組進行排序。如果數(shù)組的大小不是通過參數(shù)傳遞，而是放入一個全局變量中，那么其效率會更高，因為參數(shù)傳遞要費時間，而且還要占用額外的堆?？臻g，而全局變量可被所有函數(shù)訪問，所以不需要額外的時間和空間開銷。但是全局變量破壞了最低訪問權原則，是不良軟件工程的一個范例。如果在主調(diào)函數(shù)中再定義一個整型指針變量q,再把a的地址賦給它：

int*q=a；則函數(shù)調(diào)用語句可寫為：

simplesort(q,10)；其他任何地方都不需做修改就同樣可以完成排序任務。而這種情況是形參、實參均為指針，屬于第4種搭配。

【例7-13】輸入一個整型數(shù)組，并求出每個元素的所有因子。

編程思路：可定義兩個整型數(shù)組，一個用于存放輸入的整數(shù)，另一個用來存放一個整數(shù)的所有因子。把求一個整數(shù)的所有因子并把它們放入數(shù)組的任務用一個函數(shù)來實現(xiàn)。函數(shù)的形參中使用一個指向整數(shù)的指針，用來接收在函數(shù)調(diào)用時由主調(diào)函數(shù)提供的真實的整型數(shù)組名。程序如下：＃include<stdio.h>intfactor(int*fb,intn){inti,k;k=2;i=0;while(n!=1)if(n%k==0){ fb［i++］=k; n/=k}elsek++;returni;}main(){inta［10］,b［10］,i,j,k,n;printf(″Inputaninteger:＼n″);scanf(″%d″,&n);printf(″Input%dnumbers:＼n″,n);for(i=0;i<n;i++)scanf(″%d″,&a［i］);for(i=0;i<n;i++){j=factor(b,a［i］);printf(″%4d′sfactor:″,a［i］);for(k=0;k<j;k++)printf(″%d,″,b［k］);printf(″＼n″);}return0;}運行輸出：Inputaninteger:3↙

Input3numbers:863572694↙

86′s factor:2,43,357′s factor:3,7,17,2694′sfactor:2,3,449,

(3)實參為指針，形參為數(shù)組名。這里，實參的指針實際上代表了某個數(shù)組，所以這種情況也是數(shù)組對數(shù)組的搭配。

【例7-14】用遞歸方法將數(shù)組反序輸出。＃include<stdio.h>voidinverse(int［］,constint);main(){inti,a［10］={1,2,3,4,5,6,7,8,9,10},*q=a;puts(″Beforeinverse:＼n″);for(i=0;i<=9;i++)printf(″%d″,*q++);q=a; puts(″Afterinverse:＼n″); inverse(q,10);printf(″＼n″);return0;}voidinverse(intb［］,constintn){if(n>0){inverse(&b［1］,n-1);printf(″%d″,b［0］);}}運行輸出：

Beforeinverse:12345678910Afterinverse:10987654321主函數(shù)中用*q++來輸出數(shù)組元素，因而在輸出所有元素之后，指針q指向數(shù)組后面的內(nèi)存單元，此時若直接用inverse(q,10)調(diào)用函數(shù)必然出錯，因此必須再進行一次

q=a;這樣的復位操作，把指針q重新拉回到數(shù)組a的起始處。在函數(shù)inverse中，b［0］和b［1］都是相對的元素，僅表明它們是當前數(shù)組的第1個和第2個元素。因為在每次遞歸調(diào)用中數(shù)組的大小是不同的，它們的第1個和第2個元素也是不同的，是在不斷變化的。另外請注意遞歸調(diào)用的地點，是先對當前數(shù)組除頭元素外的其余部分進行倒置，再輸出頭元素，因此頭元素最后輸出。

(4)實參、形參皆為指針。這時實參指針指向具體的內(nèi)存單元，當函數(shù)調(diào)用時，就把實參指針所指向的單元地址賦給形參指針變量，于是形參指針也就和實參指針一樣指向同一個地方，因而函數(shù)中對形參指針的處理結果也就是對實參指針的處理結果。

【例7-15】隨機地生成一個100之內(nèi)的整型數(shù)組，統(tǒng)計其中奇數(shù)和偶數(shù)的個數(shù)，并按序?qū)⑺械钠鏀?shù)放到數(shù)組的前面，偶數(shù)放在后面。編程思路：因為要完成的任務比較多，所以可以把每個獨立的任務編成一個函數(shù)?？删幦齻€函數(shù)：生成數(shù)組的函數(shù)，排序函數(shù)，把奇偶數(shù)分別排放的函數(shù)。每個函數(shù)的形參都有指向整型的指針，而調(diào)用它們的實參也是同類型的指針，這些指針在主調(diào)函數(shù)中都已先指向了某個數(shù)組，所以函數(shù)中對形參指針的操作也是對主調(diào)函數(shù)中數(shù)組的操作。在表示數(shù)組元素時，可以使用指針加位移量的方法。程序如下：＃include<stdio.h>＃include<stdlib.h>voidshellsort(int*a,intn)//排序{inti,j,t,jump;for(jump=n/2;jump>0;jump/=2)for(i=jump;i<n;i++)for(j=i-jump;j>=0&&*(a+j)>*(a+j+jump);j-=jump){ t=*(a+j); *(a+j)=*(a+j+jump); *(a+j+jump)=t;}}voidarrange(int,*a,intn) //將奇數(shù)排在前，偶數(shù)排在后{intd1[10],d2[10],*dp1=d1,*dp2=d2,i,j=0,k=0,j1,k1;for(i=0;i<n;i++)if(*(a+i)%2==0){*(dp1+j)=*(a+i);j++;}else{*(dp2+k)=*(a+i);k++;}for(k1=0;k1<k;k1++)*(a+k1)=*(dp2+k1);for(j1=0;j1<j;j1++)*(a+j1+k1)=*(dp1+j1);}

voidprodarr(int*a,intn,int*even,int*odd) //產(chǎn)生隨機數(shù)組并統(tǒng)計奇、偶數(shù)的個數(shù){inti;for(i=0;i<n;i++){*(a+i)=rand()%100;if((*(a+i))%2==0) (*even)++;else(*odd)++;} printf(″Therandomarrayis:＼n＼n″);for(i=0;i<n;i++)printf(″%d″,*(a+i));printf(″＼n＼n″);shellsort(a,n);printf(″Aftersorted:＼n＼n″);for(i=0;i<n;i++)printf(″%d″,*(a+i));printf(″＼n＼n″);arrange(a,n);}main(){intab［10］,*ap=ab,i,m,evenn=0,oddn=0;printf(″Inputainteger:＼n＼n″);scanf(″%d″,&m);prodarr(ap,m,&evenn,&oddn);printf(″Afterarrange:＼n＼n″);for(i=0;i<m;i++)printf(″%d″,*(ap+i));printf(″\n\noddnumber=%d\nevennumber=%d\n\n″,oddn,evenn);return0;}運行輸出：Inputainteger:10Therandomarrayis:4167340692478586264Aftersorted:0243441586264676978Afterarrange:4167690243458626478oddnumber=3evennumber=7

注意：程序中求奇、偶數(shù)個數(shù)的計算是通過傳引用調(diào)用來進行的。函數(shù)調(diào)用時把在主調(diào)函數(shù)中定義的統(tǒng)計奇、偶數(shù)個數(shù)的變量evenn和oddn的地址作為實參傳遞給了函數(shù)prodarr()中的指針形參even和odd,這樣函數(shù)中對指針所指對象*even和*odd的累加實際上就是對主調(diào)函數(shù)中實在變量evenn和oddn的累加。因為自加運算符++的優(yōu)先級高于間接引用運算符*，如果寫成*even++就表示*(even++)，這樣的執(zhí)行是不對的，所以應當寫成(*even)++才正確。7.3.2字符指針字符串有兩種實現(xiàn)方法：用字符數(shù)組實現(xiàn)和用字符指針實現(xiàn)。這兩種方法實際上是一致的。前面我們已經(jīng)用字符數(shù)組實現(xiàn)了字符串，現(xiàn)在我們用字符指針來實現(xiàn)字符串。用字符指針來實現(xiàn)字符串的一般形式為：

char*〈字符指針〉用字符指針實現(xiàn)字符串時，可以在定義時對指針賦初值，也可在定義之后單獨賦值。如：

char*str=″China″；或

char*str;str=″China″；這兩種方法的操作結果都使str指向字符串“China”的第一個字符，即但它們還是有區(qū)別的。第一種情況是對字符指針賦初值，這是在編譯階段進行的；而第二種情況是在運行階段進行的，當字符指針被定義時，它的指向是隨機的，但在為它賦值的時候，編譯程序會另選擇一個合適的地方來存放字符串常量″China″。對于這種賦值，C語言是按靜態(tài)字符數(shù)組處理的，因此字符串常量″China″的地址是確定的，但它并不是指針原來所指的地方。這種字符指針在賦值前后所指地址的差異在函數(shù)調(diào)用時看得更加明顯，如以下程序：China\0str＃include<stdio.h>voidfun(char*p){p=″bbbbb″;}main(){charc［10］=″aaaaa″,*pm=c;printf(″before:pm=%s＼n″,pm);fun(pm);printf(″after:pm=%s＼n″,pm);return0;}運行輸出：before:pm=aaaaaafter:pm=aaaaa由運行結果可見函數(shù)調(diào)用并沒有改變pm的值，雖然在函數(shù)內(nèi)部通過賦值改變了形參p的值，但是由于參數(shù)的傳送是值傳送，形參p的改變和實參pm沒有關系，不能影響實參，因此在函數(shù)調(diào)用之后，pm仍然指向字符串“aaaaa”?？梢娭羔樧鲄?shù)傳遞時仍然遵從C語言中參數(shù)值傳送的規(guī)則。如果希望通過函數(shù)調(diào)用改變實參指針的值，則應該使用傳引用調(diào)用的方法，即實參用指針變量的地址，形參用指向指針的指針(二級指針)，如以下程序：＃include<stdio.h>voidfun(char**p){*p=″bbbbb″;}main(){charc［10］=″aaaaa″,*pm=c;printf(″before:pm=%s＼n″,pm);fun(&pm);printf(″after:pm=%s＼n″,pm);return0;}運行輸出：before:pm=aaaaaafter:pm=bbbbb如果在函數(shù)中不改變形參指針的值，則形參指針和實參指針指向同一個對象，函數(shù)中對形參指針的處理也是對實參指針的處理。如果下面程序所示：＃include<stdio.h>＃include<string.h>voidfun(char*p){strcpy(p,″bbbbb″);}main(){charc［10］=″aaaaa″,*pm=c;printf(″before:pm=%s＼n″,pm);fun(pm);printf(″after:pm=%s＼n″,pm);return0;}運行輸出：before:pm=aaaaaafter:pm=bbbbb這是因為在函數(shù)調(diào)用時形參p接收了實參pm的值，而在函數(shù)中又沒有改變形參p的值，使得p和pm都指向同一個內(nèi)存空間，因此函數(shù)中通過strcpy對p的賦值也就是對pm的賦值。從上面的例子可以看出，在函數(shù)中對形參字符指針賦值可以改變指針的值，而使用strcpy則不會改變指針的值，這種差別在函數(shù)調(diào)用之后對主調(diào)函數(shù)會有不同的影響。這里應指出，在指針未指向由編譯時指定的確定地址空間以前，對它進行賦值以外的輸入操作時會發(fā)生運行錯誤。如語句char*str;scanf(″%s″,str);或strcpy(str,″China″);都會引起運行錯誤。正確的方法應該是先讓指針指向確定的地址空間，然后再對它進行這樣的輸入。如語句：charc［20］,*str=c;scanf(″%s″,str);或strcpy(str,″China″);運行時就不會出錯。當然，這里輸入字符串的長度應該在數(shù)組的長度之內(nèi)。輸出字符串時，用格式控制符“%s”來控制字符指針，如：

printf(″%s″,str)；編譯器處理的機理是首先把str所指的那個字符輸出，然后自動把指針向后移一位，再把指針所指的字符輸出，再移動指針……直至遇到′＼0′字符后字符串結束。所以這是個不斷地輸出字符和移動指針的過程，并不是把字符串作為一個整體一次性地全部輸出。像對字符指針所指對象進行賦值時，不能把一個字符串常量賦進去，而只能賦一個字符。如：

char*s;*s=″China″；就是錯誤的。因為*s代表一個字符對象，相當于一個字符變量，它怎么能接收多個字符呢?下面的操作是正確的：

charc,*s=&c;*s=′a′；在對字符數(shù)組中元素的引用一樣，對字符串中字符的引用可以有多種方法，既可以用數(shù)組名，也可以用字符指針。在函數(shù)調(diào)用時，傳遞字符數(shù)組信息的參數(shù)既可以用字符數(shù)組名，也可以用字符指針。為說明數(shù)組和指針的互換性，我們看兩個實現(xiàn)字符串拷貝的函數(shù)copy1和copy2。這兩個函數(shù)都是把一個字符串(字符數(shù)組)拷貝到另一個字符數(shù)組中，雖然它們的函數(shù)原型是一樣的，但它們的實現(xiàn)過程卻是不同的。

【例7-16】字符串的拷貝。＃include<stdio.h>voidcopy1(char*,constchar*);voidcopy2(char*,constchar*);main(){charstr1［10］,*str2=″Hello″,str3［10］,*str4=″GoodBye″;copy1(str1,str2);printf(″str1=%s＼n″,str1);copy2(str3,str4);printf(″str3=%s＼n″,str3);return0;}/*用數(shù)組表示法把s2拷貝到s1*/voidcopy1(char*s1,constchar*s2){inti;for(i=0;s1［i］=s2［i］;i++);}/*用指針表示法進行字符串拷貝*/voidcopy2(char*s1,constchar*s2){for(;*s1=*s2;s1++,s2++);}運行輸出：str1=Hellostr3=GoodBye對函數(shù)copy1和copy2的調(diào)用，實參用的是數(shù)組名和指針，在copy1中定義了一個表示下標的變量i，for循環(huán)體是空語句，所有的操作都在for語句頭部完成：i初始化為0，以后每次加1；條件判斷s1［i］=s2［i］是在執(zhí)行賦值之后再根據(jù)其左值進行判斷；s2向s1一次拷貝一個字符，當把空字符′＼０′也拷貝進去之后，條件變?yōu)榧伲h(huán)結束。函數(shù)copy2通過指針運算進行拷貝，并且也用一個沒有循環(huán)體的for語句來完成。在for循環(huán)頭中沒有賦初值的操作，因為在函數(shù)調(diào)用過程中，s1和s2直接接收實參字符串(數(shù)組)的首地址，都指向第一個字符的位置。在條件判斷(*s1=*s2)中也是首先賦值而后根據(jù)已賦的值進行判斷。在字符指針前加復引用運算符就代表一個字符變量。每完成一次賦值后，都使它們分別指向字符串的下一個元素。當s2遇到空字符′＼0′時，它也被賦予*s1，這時條件為假，循環(huán)終止。在函數(shù)中，第一個參數(shù)是接收字符串的數(shù)組，必須定義得足夠大，以便能完全容納所復制的內(nèi)容；第二個參數(shù)被聲明為“constchar*”類型，意思是不允許在函數(shù)中對這個字符串加以改變，這是實現(xiàn)最低訪問權原則的要求。

【例7-17】在一定長度范圍內(nèi)輸入一串字符，然后以反序輸出之。

編程思路：這里的問題和前面的問題不同，這里輸入的字符串的長度是隨機的，不是預先確定的。要想對這樣的字符串進行倒置，必須首先確定其長度。為此我們可以專門設計一個函數(shù)，使其能確定任意字符串的長度，在長度確定之后，我們另設計一個函數(shù)來倒置字符串。

程序如下：＃include<stdio.h>

＃defineN50main(){charbuf［N］,*pb=buf;voidrev(char*);printf(″Inputastring:＼n″);gets(pb);rev(pb);printf(″Thereverseofstringis:＼n%s＼n″,buf);return0;}voidrev(char*s){intc,k;intstrlen(constchar*);char*p;k=strlen(s);for(p=s+k-1;s<p;s++,p--){c=*s;*s=*p;*p=c;}}intstrlen(constchar*a){intn=0;while(*a++)n++;printf(″Thelength=%d＼n″,n);returnn;}運行輸出：

Inputastring:IloveChina↙

Thelength=12Thereverseofstringis:anihCevolI

注意：①程序中定義了兩個函數(shù)，rev和strlen。rev函數(shù)用于倒置字符串，strlen函數(shù)用于確定字符串的長度，它們的參數(shù)都是指針類型，而調(diào)用它們時，實在參數(shù)也都是指針變量。②因被調(diào)函數(shù)出現(xiàn)在主調(diào)函數(shù)之后，所以必須預先對其進行聲明。主函數(shù)中調(diào)用了rev函數(shù)，rev函數(shù)中調(diào)用了strlen函數(shù)，根據(jù)最低訪問權原則，在主函數(shù)中可以只聲明rev函數(shù)，而把strlen函數(shù)放在調(diào)用它的rev中聲明。在strlen中，因為沒有對參數(shù)加以修改，故用const修飾；而在rev中，因為要對字符串進行倒置，故不能對它的參數(shù)進行const修飾。③主函數(shù)中用gets輸入一個字符串，這可保證在輸入的字符串中可以包含空格。如用scanf函數(shù)輸入，則遇到空格就會終止。④在strlen函數(shù)中，while(*a++)等價于while(*a++!=′\0′)，即首先判斷a指向的當前值是否為′\0′，若不為′\0′，則執(zhí)行循環(huán)體n++，計數(shù)器加1，然后a向后移一個字符位置，以作下一次循環(huán)的判斷之用。當a指向字符串的尾部′\0′時，條件為假，退出循環(huán)。求出的字符串長度是不包括′\0′的字符串長度。⑤在rev函數(shù)中，先調(diào)用strlen函數(shù)求出字符串的長度k，并對指針p賦初值：p=s+k-1，其結果是使指針p指向字符串的最后一個字符，s指向字符串的首字符。for循環(huán)體中，交換首尾指針所指的字符，然后s向后，p向前各移動一個字符位置，直到兩指針相遇為止，如圖7-7所示。圖7-7例7-14運行示意圖用字符指針處理字符串時，要注意以下問題：

(1)指針當前指向的對象是什么?必須首先將指針指向一個字符數(shù)組，即把字符數(shù)組名賦給字符指針變量，如

chars［20］,*p=s;

(2)在程序處理過程中指針移動了沒有?如程序中出現(xiàn)p++之類的操作時，則指針發(fā)生了移動，而通過*(p+i)來引用字符時則指針沒有移動。

(3)指針要不要復位?當程序中發(fā)生了移動指針的操作時，如

scanf(″%c″,p++);則在操作完成之后，指針p就不再指向數(shù)組s的首部，要想再用指針對數(shù)組進行操作，必須對指針進行復位，讓指針重新指向數(shù)組首部。即執(zhí)行語句：

p=s;

(4)字符串的后面是否有結束標志′＼0′?每個字符串的后面都必須有一個結束標志，否則在用指針對字符串進行輸出時會因找不到結束標志而不能正常終止。

(5)在對字符串進行處理時，常用while循環(huán)語句，如：

while(*p++)…也可以用for循環(huán)語句，此時不需要另外的循環(huán)控制變量，直接判斷是否到達′＼0′字符即可：

for(;*p!=′＼0′;p++)…

【例7-18】刪去字符串中間的數(shù)字字符，如對于“abcd123EFG”，輸出為“abcdEFG”。

編程思路：設計兩個字符數(shù)組，一個用于輸入，另一個用于接收前一個數(shù)組中的非數(shù)字字符，最后將不含數(shù)字字符的數(shù)組輸出。用字符指針加以處理。＃include<stdio.h>main(){chara［20］,b［20］,*p,*q;p=a;q=b;//讓指針指向數(shù)組首部printf(″Inputastring:＼n″);gets(a);while(*p)//判斷是否到結束標志，等價于*p!=′\0′{if(*p>=′0′&&*p<=′9′){p++;//移動指針

continue;}else*q++=*p++; //移動指針

}*q=′＼0′; //用′＼0′結束字符串qq=b; //對指針q進行復位printf(″Stringhavingnotnumbercharacter:＼n″);puts(q);return0;}運行輸出：Inputastring:abcd123EFGStringhaving