深入理解C语言指针的奥秘.docx
- 文档编号:4103280
- 上传时间:2022-11-27
- 格式:DOCX
- 页数:17
- 大小:27.61KB
深入理解C语言指针的奥秘.docx
《深入理解C语言指针的奥秘.docx》由会员分享,可在线阅读,更多相关《深入理解C语言指针的奥秘.docx(17页珍藏版)》请在冰豆网上搜索。
深入理解C语言指针的奥秘
讓你不再害怕指針
前言:
複雜類型說明
要瞭解指針,多多少少會出現一些比較複雜的類型,所以我先介紹
一下如何完全理解一個複雜類型,要理解複雜類型其實很簡單,一
個類型裡會出現很多運算子,他們也像普通的運算式一樣,有優先
級,其優先順序和運算優先順序一樣,所以我總結了一下其原則:
從變數名處起,根據運算子優先順序結合,一步一步分析.
下面讓我們先從簡單的類型開始慢慢分析吧:
intp;這是一個普通的整型變數
int*p;首先從P處開始,先與*結合,所以說明P是一
個指標,然後再與int結合,說明指標所指向
//的內容的類型為int型.所以P是一個返回整
//型數據的指標
intp[3];//首先從P處開始,先與[]結合,說明P是一個數
//組,然後與int結合,說明陣列裡的元素是整
//型的,所以P是一個由整型資料組成的陣列
int*p[3];//首先從P處開始,先與[]結合,因為其優先順序
//比*高,所以P是一個陣列,然後再與*結合,說明
//陣列裡的元素是指標類型,然後再與int結合,//說明指標所指向的內容的類型是整型的,所以
//P是一個由返回整型資料的指標所組成的陣列
int(*p)[3];//首先從P處開始,先與*結合,說明P是一個指標
//然後再與[]結合(與"()"這步可以忽略,只是為
//了改變優先順序),說明指標所指向的內容是一個
//陣列,然後再與int結合,說明陣列裡的元素是
//整型的.所以P是一個指向由整型資料組成的數
//組的指針
int**p;//首先從P開始,先與*結合,說是P是一個指標,然//後再與*結合,說明指標所指向的元素是指標,然//後再與int結合,說明該指標所指向的元素是整
//型數據.由於二級指標以及更高級的指標極少用
//在複雜的類型中,所以後面更複雜的類型我們就
//不考慮多級指針了,最多只考慮一級指針.
intp(int);//從P處起,先與()結合,說明P是一個函數,然後進入
//()裡分析,說明該函數有一個整型變數的參數
//然後再與外面的int結合,說明函數的返回值是
//一個整型資料
Int(*p)(int);//從P處開始,先與指標結合,說明P是一個指標,然後與
//()結合,說明指標指向的是一個函數,然後再與()裡的
//int結合,說明函數有一個int型的參數,再與最外層的
//int結合,說明函數的返回類型是整型,所以P是一個指
//向有一個整型參數且返回類型為整型的函數的指標
int*(*p(int))[3];//可以先跳過,不看這個類型,過於複雜
//從P開始,先與()結合,說明P是一個函數,然後進
//入()裡面,與int結合,說明函數有一個整型變數
//參數,然後再與外面的*結合,說明函數返回的是
//一個指標,,然後到最外面一層,先與[]結合,說明
//返回的指標指向的是一個陣列,然後再與*結合,說//明陣列裡的元素是指標,然後再與int結合,說明指
//針指向的內容是整型資料.所以P是一個參數為一個
//整數據且返回一個指向由整型指標變數組成的陣列
//的指標變數的函數.
說到這裡也就差不多了,我們的任務也就這麼多,理解了這幾個類型,其它
的類型對我們來說也是小菜了,不過我們一般不會用太複雜的類型,那樣會
大大減小程式的可讀性,請慎用,這上面的幾種類型已經足夠我們用了.
1、細說指針
指標是一個特殊的變數,它裡面存儲的數值被解釋成為記憶體裡的一個位址。
要搞清一個指標需要搞清指標的四方面的內容:
指標的類型、指標所指向的類型、指標的值或者叫指標所指向的記憶體區、指標本身所佔據的記憶體區。
讓我們分別說明。
先聲明幾個指針放著做例子:
例一:
(1)int*ptr;
(2)char*ptr;
(3)int**ptr;
(4)int(*ptr)[3];
(5)int*(*ptr)[4];
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位長。
指標所指向的記憶體區就是從指標的值所代表的那個記憶體位址開始,長度為sizeof(指標所指向的類型)的一片記憶體區。
以後,我們說一個指標的值是XX,就相當於說該指針指向了以XX為首位址的一片記憶體區域;我們說一個指標指向了某塊記憶體區域,就相當於說該指標的值是這塊記憶體區域的首位址。
指標所指向的記憶體區和指標所指向的類型是兩個完全不同的概念。
在例一中,指標所指向的類型已經有了,但由於指標還未初始化,所以它所指向的記憶體區是不存在的,或者說是無意義的。
以後,每遇到一個指標,都應該問問:
這個指標的類型是什麼?
指針指
的類型是什麼?
該指標指向了哪裡?
(重點注意)
4指標本身所佔據的記憶體區
指標本身占了多大的記憶體?
你只要用函數sizeof(指標的類型)測一下
就知道了。
在32位平臺裡,指針本身佔據了4個位元組的長度。
指標本身佔據的記憶體這個概念在判斷一個指標運算式(後面會解釋)是
否是左值時很有用。
2、指針的算數運算
指標可以加上或減去一個整數。
指標的這種運算的意義和通常的數值的加減運算的意義是不一樣的,以單元為單位。
例如:
例二:
chara[20];
int*ptr=(int*)a;//強制類型轉換並不會改變a的類型
ptr++;
在上例中,指標ptr的類型是int*,它指向的類型是int,它被初始化為指向整型變數a。
接下來的第3句中,指針ptr被加了1,編譯器是這樣處理的:
它把指針ptr的值加上了sizeof(int),在32位元程式中,是被加上了4,因為在32位元程式中,int占4個位元組。
由於位址是用位元組做單位的,故ptr所指向的位址由原來的變數a的位址向高位址方向增加了4個位元組。
由於char類型的長度是一個位元組,所以,原來ptr是指向陣列a的第0號單元開始的四個位元組,此時指向了陣列a中從第4號單元開始的四個位元組。
我們可以用一個指標和一個迴圈來遍歷一個陣列,看例子:
例三:
intarray[20]={0};
int*ptr=array;
for(i=0;i<20;i++)
{
(*ptr)++;
ptr++;
}
這個例子將整型陣列中各個單元的值加1。
由於每次迴圈都將指針ptr加1個單元,所以每次迴圈都能訪問陣列的下一個單元。
再看例子:
例四:
chara[20]="You_are_a_girl";
int*ptr=(int*)a;
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個位元組。
下面請允許我再舉一個例子:
(一個誤區)
例五:
#include
intmain()
{
chara[20]="You_are_a_girl";char*p=a;
char**ptr=&p;
//printf("p=%d\n",p);
//printf("ptr=%d\n",ptr);
//printf("*ptr=%d\n",*ptr);
printf("**ptr=%c\n",**ptr);
ptr++;
//printf("ptr=%d\n",ptr);
//printf("*ptr=%d\n",*ptr);
printf("**ptr=%c\n",**ptr);
}
誤區一、輸出答案為Y和o
誤解:
ptr是一個char的二級指標,當執行ptr++;時,會使指標加一個sizeof(char),所以輸出如上結果,這個可能只是少部分人的結果.
誤區二、輸出答案為Y和a
誤解:
ptr指向的是一個char*類型,當執行ptr++;時,會使指標加一個
sizeof(char*)(有可能會有人認為這個值為1,那就會得到誤區一的答案,這個值應該是4,參考前面內容),即&p+4;那進行一次取值運算不就指向陣列中的第五個元素了嗎?
那輸出的結果不就是陣列中第五個元素了嗎?
答案是否定的.
正解:
ptr的類型是char**,指向的類型是一個char*類型,該指向的
位址就是p的位址(&p),當執行ptr++;時,會使指標加一個sizeof(char
*),即&p+4;那*(&p+4)指向哪呢,這個你去問上帝吧,或者他會告訴你在
哪?
所以最後的輸出會是一個隨機的值,或許是一個非法操作.
總結一下:
一個指標ptrold加(減)一個整數n後,結果是一個新的指標ptrnew,
ptrnew的類型和ptrold的類型相同,ptrnew所指向的類型和ptrold
所指向的類型也相同。
ptrnew的值將比ptrold的值增加(減少)了n乘sizeof(ptrold所指向的類型)個位元組。
就是說,ptrnew所指向的記憶體區將比ptrold所指向的內存區向高(低)地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。
指針和指針進行加減:
兩個指標不能進行加法運算,這是非法操作,因為進行加法後,得到的結果指向一個不知所向的地方,而且毫無意義。
兩個指標可以進行減法操作,但必須類型相同,一般用在陣列方面,不多說了。
3、運算子&和*
這裡&是取位址運算子,*是間接運算子。
&a的運算結果是一個指標,指標的類型是a的類型加個*,指針所
指向的類型是a的類型,指標所指向的地址嘛,那就是a的地址。
*p的運算結果就五花八門了。
總之*p的結果是p所指向的東西,
這個東西有這些特點:
它的類型是p指向的類型,它所佔用的地址是p所指向的地址。
例六:
inta=12;intb;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類型的變數
//*parr是指針運算式
//*(parr+1)是指針運算式
//*(parr+2)是指針運算式
4、指針運算式
一個運算式的結果如果是一個指標,那麼這個運算式就叫指標表式。
下面是一些指針運算式的例子:
例七:
inta,b;
intarray[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;
str=*(parr+1);
str=*(parr+2);
由於指標運算式的結果是一個指標,所以指標運算式也具有指標所具有的四個要素:
指標的類型,指標所指向的類型,指標指向的記憶體區指標自身佔據的記憶體。
好了,當一個指標運算式的結果指標已經明確地具有了指標自身占據的記憶體的話,這個指標運算式就是一個左值,否則就不是一個值。
在例七中,&a不是一個左值,因為它還沒有佔據明確的記憶體。
*ptr是一個左值,因為*ptr這個指標已經佔據了記憶體,其實*ptr就是指標pa既然pa已經在記憶體中有了自己的位置,那麼*ptr當然也有了自己的位置。
5、陣列和指標的關係
陣列的陣列名稱其實可以看作一個指標。
看下例:
例九:
Intarray[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],但如
果把array看做指標的話,它指向陣列的第0個單元,類型是int*,
所指向的類型是陣列單元的類型即int。
因此*array等於0就一點也不
奇怪了。
同理,array+3是一個指向陣列第3個單元的指標,所以
*(array+3)等於3。
其它依此類推。
例十:
char*str[3]={"Hello,thisisasample!
","Hi,goodmoorning.","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是一個三單元的陣列,該陣列的每個單元都是一個指標,
這些指標各指向一個字串。
把指標陣列名稱str當作一個指標的話,它
指向陣列的第0號單元,它的類型是char**,它指向的類型是char*
*str也是一個指標,它的類型是char*,它所指向的類型是char,它
指向的位址是字串"Hello,thisisasample!
"的第一個字元的位址,即
'H'的地址。
注意:
字串相當於是一個陣列,在記憶體中以陣列的形式儲
存,只不過字串是一個陣列常量,內容不可改變,且只能是右值.如果看成指針的話,他即是常量指針,也是指針常量.
str+1也是一個指標,它指向陣列的第1號單元,它的類型是char**,
它指向的類型是char*。
*(str+1)也是一個指標,它的類型是char*,它所指向的類型是char,它指向"Hi,goodmorning."的第一個字元'H'
下面總結一下陣列的陣列名稱(陣列中儲存的也是陣列)的問題:
聲明了一個陣列TYPEarray[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扮演的是指針,故array+n的結果是一個指標,它的類型是TYPE*,它指向的類型是TYPE,它指向陣列第n號單元。
故sizeof(array+n)測出的是指針類型的大小。
在32位元程式中結果是4
例十一:
intarray[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(物件)測出的都是物件自身的類型的大小,而不是別的
什麼類型的大小。
6、指標和結構類型的關係
可以聲明一個指向結構類型物件的指標。
例十二:
structMyStruct
{
inta;intb;intc;
};
structMyStructss={20,30,40};
//聲明了結構物件ss,並把ss的成員初始化為20,30和40
structMyStruct*ptr=&ss;
//聲明了一個指向結構物件ss的指標。
它的類型是
//MyStruct*,它指向的類型是MyStruct。
int*pstr=(int*)&ss;
//聲明了一個指向結構物件ss的指標。
但是pstr和
//它被指向的類型ptr是不同的。
請問怎樣通過指針ptr來訪問ss的三個成員變數?
答案:
ptr->a;//指向運算子,或者可以這們(*ptr).a,建議使用前者
ptr->b;
ptr->c;
又請問怎樣通過指針pstr來訪問ss的三個成員變數?
答案:
*pstr;//訪問了ss的成員a。
*(pstr+1);//訪問了ss的成員b。
*(pstr+2)//訪問了ss的成員c。
雖然我在我的MSVC++6.0上調式過上述代碼,但是要知道,這樣使用pstr來訪問結構成員是不正規的,為了說明為什麼不正規,讓我們看看怎樣通過指標來訪問陣列的各個單元:
(將結構體換成陣列)
例十三:
intarray[3]={35,56,37};
int*pa=array;
通過指標pa訪問陣列array的三個單元的方法是:
*pa;//訪問了第0號單元
*(pa+1);//訪問了第1號單元
*(pa+2);//訪問了第2號單元
從格式上看倒是與通過指標訪問結構成員的不正規方法的格式一樣。
所有的C/C++編譯器在排列陣列的單元時,總是把各個陣列單元存放在連續的存儲區裡,單元和單元之間沒有空隙。
但在存放結構物件的各個成員時,在某種編譯環境下,可能會需要字對齊或雙字對齊或者是別的什麼對齊,需要在相鄰兩個成員之間加若干個"填充位元組",這就導致各個成員之間可能會有若干個位元組的空隙。
所以,在例十二中,即使*pstr訪問到了結構物件ss的第一個成員變數a,也不能保證*(pstr+1)就一定能訪問到結構成員b。
因為成員a和成員b之間可能會有若干填充位元組,說不定*(pstr+1)就正好訪問到了這些填充位元組呢。
這也證明了指針的靈活性。
要是你的目的就是想
看看各個結構成員之間到底有沒有填充位元組,嘿,這倒是個不錯的方法不過指標訪問結構成員的正確方法應該是象例十二中使用指標ptr的方法。
7、指標和函數的關係
可以把一個指標聲明成為一個指向函數的指標。
intfun1(char*,int);
int(*pfun1)(char*,int);
pfun1=fun1;
inta=(*pfun1)("abcdefg",7);//通過函數指標調用函數。
可以把指標作為函數的形參。
在函式呼叫語句中,可以用指標運算式來作為實參。
例十四:
intfun(char*);
inta;
charstr[]="
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 深入 理解 语言 指针 奥秘