0
  • 聊天消息
  • 系統(tǒng)消息
  • 評論與回復(fù)
登錄后你可以
  • 下載海量資料
  • 學(xué)習(xí)在線課程
  • 觀看技術(shù)視頻
  • 寫文章/發(fā)帖/加入社區(qū)
會員中心
創(chuàng)作中心

完善資料讓更多小伙伴認(rèn)識你,還能領(lǐng)取20積分哦,立即完善>

3天內(nèi)不再提示

詳解C語言指針底層基本原理

嵌入式開發(fā)愛好者 ? 來源:嵌入式開發(fā)愛好者 ? 2023-04-06 10:43 ? 次閱讀

說到指針,估計還是有很多小伙伴都還是云里霧里的,有點(diǎn)“知其然,而不知其所以然”。但是,不得不說,學(xué)了指針,C語言才能算是入門了。指針是C語言的「精華」,可以說,對對指針的掌握程度,「直接決定」了你C語言的編程能力。

在講指針之前,我們先來了解下變量在「內(nèi)存」中是如何存放的。

在程序中定義一個變量,那么在程序編譯的過程中,系統(tǒng)會根據(jù)你定義變量的類型來分配「相應(yīng)尺寸」的內(nèi)存空間。那么如果要使用這個變量,只需要用變量名去訪問即可。

通過變量名來訪問變量,是一種「相對安全」的方式。因為只有你定義了它,你才能夠訪問相應(yīng)的變量。這就是對內(nèi)存的基本認(rèn)知。但是,如果光知道這一點(diǎn)的話,其實(shí)你還是不知道內(nèi)存是如何存放變量的,因為底層是如何工作的,你依舊不清楚。

那么如果要繼續(xù)深究的話,你就需要把變量在內(nèi)存中真正的樣子是什么搞清楚。內(nèi)存的最小索引單元是1字節(jié),那么你其實(shí)可以把內(nèi)存比作一個超級大的「字符型數(shù)組」。在上一節(jié)我們講過,數(shù)組是有下標(biāo)的,我們是通過數(shù)組名和下標(biāo)來訪問數(shù)組中的元素。那么內(nèi)存也是一樣,只不過我們給它起了個新名字:地址。每個地址可以存放「1字節(jié)」的數(shù)據(jù),所以如果我們需要定義一個整型變量,就需要占據(jù)4個內(nèi)存單元。

那么,看到這里你可能就明白了:其實(shí)在程序運(yùn)行的過程中,完全不需要變量名的參與。變量名只是方便我們進(jìn)行代碼的編寫和閱讀,只有程序員和編譯器知道這個東西的存在。而編譯器還知道具體的變量名對應(yīng)的「內(nèi)存地址」,這個是我們不知道的,因此編譯器就像一個橋梁。當(dāng)讀取某一個變量的時候,編譯器就會找到變量名所對應(yīng)的地址,讀取對應(yīng)的值。

初識指針和指針變量

那么我們現(xiàn)在就來切入正題,指針是個什么東西呢?

所謂指針,就是內(nèi)存地址(下文簡稱地址)。C語言中設(shè)立了專門的「指針變量」來存儲指針,和「普通變量」不一樣的是,指針變量存儲的是「地址」。

定義指針

指針變量也有類型,實(shí)際上取決于地址指向的值的類型。那么如何定義指針變量呢:

很簡單:類型名* 指針變量名

char*pa;//定義一個字符變量的指針,名稱為pa
int*pb;//定義一個整型變量的指針,名稱為pb
float*pc;//定義一個浮點(diǎn)型變量的指針,名稱為pc

注意,指針變量一定要和指向的變量的類型一樣,不然類型不同可能在內(nèi)存中所占的位置不同,如果定義錯了就可能導(dǎo)致出錯。

取地址運(yùn)算符和取值運(yùn)算符

獲取某個變量的地址,使用取地址運(yùn)算符&,如:

char*pa=&a;
int*pb=&f;

如果反過來,你要訪問指針變量指向的數(shù)據(jù),那么你就要使用取值運(yùn)算符*,如:

printf("%c,%d ",*pa,*pb);

這里你可能發(fā)現(xiàn),定義指針的時候也使用了*,這里屬于符號的「重用」,也就是說這種符號在不同的地方就有不同的用意:在定義的時候表示「定義一個指針變量」,在其他的時候則用來「獲取指針變量指向的變量的值」

直接通過變量名來訪問變量的值稱之為直接訪問,通過指針這樣的形式訪問稱之為間接訪問,因此取值運(yùn)算符有時候也成為「間接運(yùn)算符」。

比如:

//Example01
//代碼來源于網(wǎng)絡(luò),非個人原創(chuàng)
#include
intmain(void)
{
chara='f';
intf=123;
char*pa=&a;
int*pf=&f;

printf("a=%c ",*pa);
printf("f=%d ",*pf);

*pa='c';
*pf+=1;

printf("now,a=%c ",*pa);
printf("now,f=%d ",*pf);

printf("sizeofpa=%d ",sizeof(pa));
printf("sizeofpf=%d ",sizeof(pf));

printf("theaddrofais:%p ",pa);
printf("theaddroffis:%p ",pf);

return0;
}

程序?qū)崿F(xiàn)如下:

//Consequence 01
a = f
f = 123
now, a = c
now, f = 124
sizeof pa = 4
sizeof pf = 4
the addr of a is: 00EFF97F
the addr of f is: 00EFF970

避免訪問未初始化的指針

voidf()
{
int*a;
*a=10;
}

像這樣的代碼是十分危險的。因為指針a到底指向哪里,我們不知道。就和訪問未初始化的普通變量一樣,會返回一個「隨機(jī)值」。

但是如果是在指針里面,那么就有可能覆蓋到「其他的內(nèi)存區(qū)域」,甚至可能是系統(tǒng)正在使用的「關(guān)鍵區(qū)域」,十分危險。不過這種情況,系統(tǒng)一般會駁回程序的運(yùn)行,此時程序會被「中止」「報錯」。

要是萬一中獎的話,覆蓋到一個合法的地址,那么接下來的賦值就會導(dǎo)致一些有用的數(shù)據(jù)被「莫名其妙地修改」,這樣的bug是十分不好排查的,因此使用指針的時候一定要注意初始化。

指針和數(shù)組

有些讀者可能會有些奇怪,指針和數(shù)組又有什么關(guān)系?這倆貨明明八竿子打不著井水不犯河水。別著急,接著往下看,你的觀點(diǎn)有可能會改變。

數(shù)組的地址

我們剛剛說了,指針實(shí)際上就是變量在「內(nèi)存中的地址」,那么如果有細(xì)心的小伙伴就可能會想到,像數(shù)組這樣的一大摞變量的集合,它的地址是啥呢?

我們知道,從標(biāo)準(zhǔn)輸入流中讀取一個值到變量中,用的是scanf函數(shù),一般貌似在后面都要加上&,這個其實(shí)就是我們剛剛說的「取地址運(yùn)算符」。如果你存儲的位置是指針變量的話,那就不需要。

//Example02
intmain(void)
{
inta;
int*p=&a;

printf("請輸入一個整數(shù):");
scanf("%d",&a);//此處需要&
printf("a=%d ",a);

printf("請再輸入一個整數(shù):");
scanf("%d",p);//此處不需要&
printf("a=%d ",a);

return0;
}

程序運(yùn)行如下:

//Consequence 02
請輸入一個整數(shù):1
a = 1
請再輸入一個整數(shù):2
a = 2

在普通變量讀取的時候,程序需要知道這個變量在內(nèi)存中的地址,因此需要&來取地址完成這個任務(wù)。而對于指針變量來說,本身就是「另外一個」普通變量的「地址信息」,因此直接給出指針的值就可以了。

試想一下,我們在使用scanf函數(shù)的時候,是不是也有不需要使用&的時候?就是在讀取「字符串」的時候:

//Example03
#include
intmain(void)
{
charurl[100];
url[99]='?';
printf("請輸入TechZone的域名:");
scanf("%s",url);//此處也不用&
printf("你輸入的域名是:%s ",url);
return0;
}

程序執(zhí)行如下:

//Consequence 03
請輸入TechZone的域名:www.techzone.ltd
你輸入的域名是:www.techzone.ltd

因此很好推理:數(shù)組名其實(shí)就是一個「地址信息」,實(shí)際上就是數(shù)組「第一個元素的地址」

咱們試試把第一個元素的地址和數(shù)組的地址做個對比就知道了:

//Example03V2
#include
intmain(void)
{
charurl[100];
printf("請輸入TechZone的域名:");
url[99]='?';
scanf("%s",url);
printf("你輸入的域名是:%s ",url);

printf("url的地址為:%p ",url);
printf("url[0]的地址為:%p ",&url[0]);

if(url==&url[0])
{
printf("兩者一致!");
}
else
{
printf("兩者不一致!");
}
return0;
}

程序運(yùn)行結(jié)果為:

//Comsequense 03 V2
請輸入TechZone的域名:www.techzone.ltd
你輸入的域名是:www.techzone.ltd
url的地址為:0063F804
url[0]的地址為:0063F804
兩者一致!

這么看,應(yīng)該是實(shí)錘了。那么數(shù)組后面的元素也就是依次往后放置,有興趣的也可以自己寫代碼嘗試把它們輸出看看。

指向數(shù)組的指針

剛剛我們驗證了數(shù)組的地址就是數(shù)組第一個元素的地址。那么指向數(shù)組的指針自然也就有兩種定義的方法:

...
char*p;
//方法1
p=a;
//方法2
p=&a[0];

指針的運(yùn)算

當(dāng)指針指向數(shù)組元素的時候,可以對指針變量進(jìn)行「加減」運(yùn)算,+n表示指向p指針?biāo)赶虻脑氐?strong>「下n個元素」,-n表示指向p指針?biāo)赶虻脑氐?strong>「上n個元素」。并不是將地址加1。

如:

//Example04
#include
intmain(void)
{
inta[]={1,2,3,4,5};
int*p=a;
printf("*p=%d,*(p+1)=%d,*(p+2)=%d ",*p,*(p+1),*(p+2));
printf("*p->%p,*(p+1)->%p,*(p+2)->%p ",p,p+1,p+2);
return0;
}

執(zhí)行結(jié)果如下:

//Consequence 04
*p = 1, *(p+1) = 2, *(p+2) = 3
*p -> 00AFF838, *(p+1) -> 00AFF83C, *(p+2) -> 00AFF840

有的小伙伴可能會想,編譯器是怎么知道訪問下一個元素而不是地址直接加1呢?

其實(shí)就在我們定義指針變量的時候,就已經(jīng)告訴編譯器了。如果我們定義的是整型數(shù)組的指針,那么指針加1,實(shí)際上就是加上一個sizeof(int)的距離。相對于標(biāo)準(zhǔn)的下標(biāo)訪問,使用指針來間接訪問數(shù)組元素的方法叫做指針法。

其實(shí)使用指針法來訪問數(shù)組的元素,不一定需要定義一個指向數(shù)組的單獨(dú)的指針變量,因為數(shù)組名自身就是指向數(shù)組「第一個元素」的指針,因此指針法可以直接作用于數(shù)組名:

...
printf("p->%p,p+1->%p,p+2->%p ",a,a+1,a+2);
printf("a=%d,a+1=%d,a+2=%d",*a,*(a+1),*(a+2));
...

執(zhí)行結(jié)果如下:

p->00AFF838,p+1->00AFF83C,p+2->00AFF840
b=1,b+1=2,b+2=3

現(xiàn)在你是不是感覺,數(shù)組和指針有點(diǎn)像了呢?不過筆者先提醒,數(shù)組和指針雖然非常像,但是絕對「不是」一種東西。

甚至你還可以直接用指針來定義字符串,然后用下標(biāo)法來讀取每一個元素:

//Example05
//代碼來源于網(wǎng)絡(luò)
#include
#include
intmain(void)
{
char*str="IloveTechZone!";
inti,length;

length=strlen(str);

for(i=0;i {
printf("%c",str[i]);
}
printf(" ");

return0;
}

程序運(yùn)行如下:

//Consequence 05
I love TechZone!

在剛剛的代碼里面,我們定義了一個「字符指針」變量,并且初始化成指向一個字符串。后來的操作,不僅在它身上可以使用「字符串處理函數(shù)」,還可以用「下標(biāo)法」訪問字符串中的每一個字符。

當(dāng)然,循環(huán)部分這樣寫也是沒毛病的:

...
for(i=0,i {
printf("%c",*(str+i));
}

這就相當(dāng)于利用了指針法來讀取。

指針和數(shù)組的區(qū)別

剛剛說了許多指針和數(shù)組相互替換的例子,可能有的小伙伴又開始說:“這倆貨不就是一個東西嗎?”

隨著你對指針和數(shù)組越來越了解,你會發(fā)現(xiàn),C語言的創(chuàng)始人不會這么無聊去創(chuàng)建兩種一樣的東西,還叫上不同的名字。指針和數(shù)組終究是「不一樣」的。

比如筆者之前看過的一個例子:

//Example06
//代碼來源于網(wǎng)絡(luò)
#include
intmain(void)
{
charstr[]="IloveTechZone!";
intcount=0;

while(*str++!='?')
{
count++;
}
printf("總共有%d個字符。 ",count);

return0;
}

當(dāng)編譯器報錯的時候,你可能會開始懷疑你學(xué)了假的C語言語法:

//Error in Example 06
錯誤(活動)E0137表達(dá)式必須是可修改的左值
錯誤C2105“++”需要左值

我們知道,*str++ != ‘?’是一個復(fù)合表達(dá)式,那么就要遵循「運(yùn)算符優(yōu)先級」來看。具體可以回顧《C語言運(yùn)算符優(yōu)先級及ASCII對照表》。

str++比*str的優(yōu)先級「更高」,但是自增運(yùn)算符要在「下一條語句」的時候才能生效。所以這個語句的理解就是,先取出str所指向的值,判斷是否為?,若是,則跳出循環(huán),然后str指向下一個字符的位置。

看上去貌似沒啥毛病,但是,看看編譯器告訴我們的東西:表達(dá)式必須是可修改的左值

++的操作對象是str,那么str到底是不是「左值」呢?

如果是左值的話,那么就必須滿足左值的條件。

?

擁有用于識別和定位一個存儲位置的標(biāo)識符

存儲值可修改

?

第一點(diǎn),數(shù)組名str是可以滿足的,因為數(shù)組名實(shí)際上就是定位數(shù)組第一個元素的位置。但是第二點(diǎn)就不滿足了,數(shù)組名實(shí)際上是一個地址,地址是「不可以」修改的,它是一個常量。如果非要利用上面的思路來實(shí)現(xiàn)的話,可以將代碼改成這樣:

//Example06V2
//代碼來源于網(wǎng)絡(luò)
#include
intmain(void)
{
charstr[]="IloveTechZone!";
char*target=str;
intcount=0;

while(*target++!='?')
{
count++;
}
printf("總共有%d個字符。 ",count);

return0;
}

這樣就可以正常執(zhí)行了:

//Consequence 06 V2
總共有16個字符。

這樣我們就可以得出:數(shù)組名只是一個「地址」,而指針是一個「左值」。

指針數(shù)組?數(shù)組指針?

看下面的例子,你能分辨出哪個是指針數(shù)組,哪個是數(shù)組指針嗎?

int*p1[5];
int(*p2)[5];

單個的我們都可以判斷,但是組合起來就有些難度了。

答案:

int*p1[5];//指針數(shù)組
int(*p2)[5];//數(shù)組指針

我們挨個來分析。

指針數(shù)組

數(shù)組下標(biāo)[]的優(yōu)先級是最高的,因此p1是一個有5個元素的「數(shù)組」。那么這個數(shù)組的類型是什么呢?答案就是int*,是「指向整型變量的指針」。因此這是一個「指針數(shù)組」。

那么這樣的數(shù)組應(yīng)該怎么樣去初始化呢?

你可以定義5個變量,然后挨個取地址來初始化。

不過這樣太繁瑣了,但是,并不是說指針數(shù)組就沒什么用。

比如:

//Example07
#include
intmain(void)
{
char*p1[5]={
"人生苦短,我用Python。",
"PHP是世界上最好的語言!",
"Onemorething...",
"一個好的程序員應(yīng)該是那種過單行線都要往兩邊看的人。",
"C語言很容易讓你犯錯誤;C++看起來好一些,但當(dāng)你用它時,你會發(fā)現(xiàn)會死的更慘。"
};
inti;
for(i=0;i {
printf("%s ",p1[i]);
}
return0;
}

結(jié)果如下:

//Consequence 07
人生苦短,我用Python。
PHP是世界上最好的語言!
One more thing...
一個好的程序員應(yīng)該是那種過單行線都要往兩邊看的人。
C語言很容易讓你犯錯誤;C++看起來好一些,但當(dāng)你用它時,你會發(fā)現(xiàn)會死的更慘。

這樣是不是比二維數(shù)組來的更加直接更加通俗呢?

數(shù)組指針

()和[]在優(yōu)先級里面屬于「同級」,那么就按照「先后順序」進(jìn)行。

int(*p2)將p2定義為「指針」, 后面跟隨著一個5個元素的「數(shù)組」,p2就指向這個數(shù)組。因此,數(shù)組指針是一個「指針」,它指向的是一個數(shù)組。

但是,如果想對數(shù)組指針初始化的時候,千萬要小心,比如:

//Example08
#include
intmain(void)
{
int(*p2)[5]={1,2,3,4,5};
inti;
for(i=0;i {
printf("%d ",*(p2+i));
}
return0;
}

Visual Studio 2019報出以下的錯誤:

//Error and Warning in Example 08
錯誤(活動)E0146初始值設(shè)定項值太多
錯誤C2440“初始化”: 無法從“initializer list”轉(zhuǎn)換為“int (*)[5]”
警告C4477“printf”: 格式字符串“%d”需要類型“int”的參數(shù),但可變參數(shù) 1 擁有了類型“int *”

這其實(shí)是一個非常典型的錯誤使用指針的案例,編譯器提示說這里有一個「整數(shù)」賦值給「指針變量」的問題,因為p2歸根結(jié)底還是指針,所以應(yīng)該給它傳遞一個「地址」才行,更改一下:

//Example08V2
#include
intmain(void)
{
inttemp[5]={1,2,3,4,5};
int(*p2)[5]=temp;
inti;
for(i=0;i {
printf("%d ",*(p2+i));
}
return0;
} //Error and Warning in Example 08 V2
錯誤(活動)E0144"int *" 類型的值不能用于初始化 "int (*)[5]" 類型的實(shí)體
錯誤C2440“初始化”: 無法從“int [5]”轉(zhuǎn)換為“int (*)[5]”
警告C4477“printf”: 格式字符串“%d”需要類型“int”的參數(shù),但可變參數(shù) 1 擁有了類型“int *”

可是怎么還是有問題呢?

我們回顧一下,指針是如何指向數(shù)組的。

inttemp[5]={1,2,3,4,5};
int*p=temp;

我們原本以為,指針p是指向數(shù)組的指針,但是實(shí)際上「并不是」。仔細(xì)想想就會發(fā)現(xiàn),這個指針實(shí)際上是指向的數(shù)組的「第一個元素」,而不是指向數(shù)組。因為數(shù)組里面的元素在內(nèi)存中都是挨著個兒存放的,因此只需要知道第一個元素的地址,就可以訪問到后面的所有元素。

但是,這么來看的話,指針p指向的就是一個「整型變量」的指針,并不是指向「數(shù)組」的指針。而剛剛我們用的數(shù)組指針,才是指向數(shù)組的指針。因此,應(yīng)該將「數(shù)組的地址」傳遞給數(shù)組指針,而不是將第一個元素的地址傳入,盡管它們值相同,但是「含義」確實(shí)不一樣:

//Example08V3
//Example08V2
#include
intmain(void)
{
inttemp[5]={1,2,3,4,5};
int(*p2)[5]=&temp;//此處取地址
inti;
for(i=0;i {
printf("%d ",*(*p2+i));
}
return0;
}

程序運(yùn)行如下:

//Consequence 08
1
2
3
4
5

指針和二維數(shù)組

在上一節(jié)《C語言之?dāng)?shù)組》我們講過「二維數(shù)組」的概念,并且我們也知道,C語言的二維數(shù)組其實(shí)在內(nèi)存中也是「線性存放」的。

假設(shè)我們定義了:int array[4][5]

array

array作為數(shù)組的名稱,顯然應(yīng)該表示的是數(shù)組的「首地址」。由于二維數(shù)組實(shí)際上就是一維數(shù)組的「線性拓展」,因此array應(yīng)該就是指的指向包含5個元素的數(shù)組的指針。

如果你用sizeof()去測試array和array+1的話,就可以測試出來這樣的結(jié)論。

*(array+1)

首先從剛剛的問題我們可以得出,array+1同樣也是指的指向包含5個元素的數(shù)組的指針,因此*(array+1)就是相當(dāng)于array[1],而這剛好相當(dāng)于array[1][0]的數(shù)組名。因此*(array+1)就是指第二行子數(shù)組的第一個元素的地址。

*(*(array+1)+2)

有了剛剛的結(jié)論,我們就不難推理出,這個實(shí)際上就是array[1][2]。是不是感覺非常簡單呢?

總結(jié)一下,就是下面的這些結(jié)論,記住就好,理解那當(dāng)然更好:

*(array+i)==array[i]
*(*(array+i)+j)==array[i][j]
*(*(*(array+i)+j)+k)==array[i][j][k]
...

數(shù)組指針和二維數(shù)組

我們在上一節(jié)里面講過,在初始化二維數(shù)組的時候是可以偷懶的:

intarray[][3]={
{1,2,3},
{4,5,6}
};

剛剛我們又說過,定義一個數(shù)組指針是這樣的:

int(*p)[3];

那么組合起來是什么意思呢?

int(*p)[3]=array;

通過剛剛的說明,我們可以知道,array是指向一個3個元素的數(shù)組的「指針」,所以這里完全可以將array的值賦值給p。

其實(shí)C語言的指針非常靈活,同樣的代碼用不同的角度去解讀,就可以有不同的應(yīng)用。

那么如何使用指針來訪問二維數(shù)組呢?沒錯,就是使用「數(shù)組指針」

//Example09
#include
intmain(void)
{
intarray[3][4]={
{0,1,2,3},
{4,5,6,7},
{8,9,10,11}
};
int(*p)[4];
inti,j;
p=array;
for(i=0,i {
for(j=0,j {
printf("%2d",*(*(p+i)+j));
}
printf(" ");
}
return0;
}

運(yùn)行結(jié)果:

//Consequence 09
0 1 2 3
4 5 6 7
8 9 10 11

void指針

void實(shí)際上是無類型的意思。如果你嘗試用它來定義一個變量,編譯器肯定會「報錯」,因為不同類型所占用的內(nèi)存有可能「不一樣」。但是如果定義的是一個指針,那就沒問題。void類型中指針可以指向「任何一個類型」的數(shù)據(jù),也就是說,任何類型的指針都可以賦值給void指針。

將任何類型的指針轉(zhuǎn)換為void是沒有問題的。但是如果你要反過來,那就需要「強(qiáng)制類型轉(zhuǎn)換」。此外,不要對void指針「直接解引用」,因為編譯器其實(shí)并不知道void指針會存放什么樣的類型。

//Example10
#include
intmain(void)
{
intnum=1024;
int*pi=#
char*ps="TechZone";
void*pv;

pv=pi;
printf("pi:%p,pv:%p ",pi,pv);
printf("*pv:%d ",*pv);

pv=ps;
printf("ps:%p,pv:%p ",ps,pv);
printf("*pv:%s ",*pv);
}

這樣會報錯:

//Error in Example 10
錯誤C2100非法的間接尋址
錯誤C2100非法的間接尋址

如果一定要這么做,那么可以用「強(qiáng)制類型轉(zhuǎn)換」

//Example10V2
#include
intmain(void)
{
intnum=1024;
int*pi=#
char*ps="TechZone";
void*pv;

pv=pi;
printf("pi:%p,pv:%p ",pi,pv);
printf("*pv:%d ",*(int*)pv);

pv=ps;
printf("ps:%p,pv:%p ",ps,pv);
printf("*pv:%s ",pv);
}

當(dāng)然,使用void指針一定要小心,由于void指針幾乎可以「通吃」所有類型,所以間接使得不同類型的指針轉(zhuǎn)換變得合法,如果代碼中存在不合理的轉(zhuǎn)換,編譯器也不會報錯。

因此,void指針能不用則不用,后面講函數(shù)的時候,還可以解鎖更多新的玩法。

NULL指針

在C語言中,如果一個指針不指向任何數(shù)據(jù),那么就稱之為「空指針」,用「NULL」來表示。NULL其實(shí)是一個宏定義:

#defineNULL((void*)0)

在大部分的操作系統(tǒng)中,地址0通常是一個「不被使用」的地址,所以如果一個指針指向NULL,就意味著不指向任何東西。為什么一個指針要指向NULL呢?

其實(shí)這反而是一種比較指的推薦的「編程風(fēng)格」——當(dāng)你暫時還不知道該指向哪兒的時候,就讓它指向NULL,以后不會有太多的麻煩,比如:

//Example11
#include
intmain(void)
{
int*p1;
int*p2=NULL;
printf("%d ",*p1);
printf("%d ",*p2);
return0;
}

第一個指針未被初始化。在有的編譯器里面,這樣未初始化的變量就會被賦予「隨機(jī)值」。這樣指針被稱為「迷途指針」,「野指針」或者「懸空指針」。如果后面的代碼對這類指針解引用,而這個地址又剛好是合法的話,那么就會產(chǎn)生莫名其妙的結(jié)果,甚至導(dǎo)致程序的崩潰。因此養(yǎng)成良好的習(xí)慣,在暫時不清楚的情況下使用NULL,可以節(jié)省大量的后期調(diào)試的時間。

指向指針的指針

開始套娃了。其實(shí)只要你理解了指針的概念,也就沒什么大不了的。

//Example12
#include
intmain(void)
{
intnum=1;
int*p=#
int**pp=&p;

printf("num:%d ",num);
printf("*p:%d ",*p);
printf("**p:%d ",**pp);
printf("&p:%p,pp:%p ",&p,pp);
printf("&num:%p,p:%p,*pp:%p ",&num,p,*pp);
return0;
}

程序結(jié)果如下:

//Consequence 12
num: 1
*p: 1
**p: 1
&p: 004FF960, pp: 004FF960
&num: 004FF96C, p: 004FF96C, *pp: 004FF96C

當(dāng)然你也可以無限地套娃,一直指下去。不過這樣會讓代碼可讀性變得「很差」,過段時間可能你自己都看不懂你寫的代碼了。

指針數(shù)組和指向指針的指針

那么,指向指針的指針有什么用呢?

它可不是為了去創(chuàng)造混亂代碼,在一個經(jīng)典的實(shí)例里面,就可以體會到它的用處:

char*Books[]={
"《C專家編程》",
"《C和指針》",
"《C的陷阱與缺陷》",
"《CPrimerPlus》",
"《Python基礎(chǔ)教程(第三版)》"
};

然后我們需要將這些書進(jìn)行分類。我們發(fā)現(xiàn),其中有一本是寫Python的,其他都是C語言的。這時候指向指針的指針就派上用場了。首先,我們剛剛定義了一個指針數(shù)組,也就是說,里面的所有元素的類型「都是指針」,而數(shù)組名卻又可以用指針的形式來「訪問」,因此就可以使用「指向指針的指針」來指向指針數(shù)組:

...
char**Python;
char**CLang[4];

Python=&Books[5];
CLang[0]=&Books[0];
CLang[1]=&Books[1];
CLang[2]=&Books[2];
CLang[3]=&Books[3];
...

因為字符串的取地址值實(shí)際上就是其「首地址」,也就是一個「指向字符指針的指針」,所以可以這樣賦值。

這樣,我們就利用指向指針的指針完成了對書籍的分類,這樣既避免了浪費(fèi)多余的內(nèi)存,而且當(dāng)其中的書名要修改,只需要改一次即可,代碼的靈活性和安全性都得到了提升。

常量和指針

常量,在我們目前的認(rèn)知里面,應(yīng)該是這樣的:

520, 'a'

或者是這樣的:

#defineMAX1000
#defineB'b'

常量和變量最大的區(qū)別,就是前者「不能夠被修改」,后者可以。那么在C語言中,可以將變量變成像具有常量一樣的特性,利用const即可。

constintmax=1000;
constchara='a';

在const關(guān)鍵字的作用下,變量就會「失去」本來具有的可修改的特性,變成“只讀”的屬性。

指向常量的指針

強(qiáng)大的指針當(dāng)然也是可以指向被const修飾過的變量,但這就意味著「不能通過」指針來修改它所引用的值??偨Y(jié)一下,就是以下4點(diǎn):

指針可以修改為指向不同的變量

指針可以修改為指向不同的常量

可以通過解引用來讀取指針指向的數(shù)據(jù)

不可以通過解引用來修改指針指向的數(shù)據(jù)

常量指針

指向非常量的常量指針

指針本身作為一種「變量」,也是可以修改的。因此,指針也是可以被const修飾的,只不過位置稍稍「發(fā)生了點(diǎn)變化」

...
int*constp=#
...

這樣的指針有如下的特性:

指針自身不能夠被修改

指針指向的值可以被修改

指向常量的常量指針

在定義普通變量的時候也用const修飾,就得到了這樣的指針。不過由于限制太多,一般很少用到:

...
intnum=100;
constintcnum=200;
constint*constp=&cnum;
...

審核編輯:湯梓紅
聲明:本文內(nèi)容及配圖由入駐作者撰寫或者入駐合作網(wǎng)站授權(quán)轉(zhuǎn)載。文章觀點(diǎn)僅代表作者本人,不代表電子發(fā)燒友網(wǎng)立場。文章及其配圖僅供工程師學(xué)習(xí)之用,如有內(nèi)容侵權(quán)或者其他違規(guī)問題,請聯(lián)系本站處理。 舉報投訴
  • 內(nèi)存
    +關(guān)注

    關(guān)注

    8

    文章

    3103

    瀏覽量

    74918
  • C語言
    +關(guān)注

    關(guān)注

    180

    文章

    7628

    瀏覽量

    139977
  • 數(shù)組
    +關(guān)注

    關(guān)注

    1

    文章

    419

    瀏覽量

    26329
  • 運(yùn)算符
    +關(guān)注

    關(guān)注

    0

    文章

    172

    瀏覽量

    11303
  • 指針變量
    +關(guān)注

    關(guān)注

    0

    文章

    17

    瀏覽量

    7284

原文標(biāo)題:詳解 C 語言指針底層基本原理

文章出處:【微信號:嵌入式開發(fā)愛好者,微信公眾號:嵌入式開發(fā)愛好者】歡迎添加關(guān)注!文章轉(zhuǎn)載請注明出處。

收藏 人收藏

    評論

    相關(guān)推薦
    熱點(diǎn)推薦

    擴(kuò)頻通信的基本原理

    附件非常詳解的介紹了擴(kuò)頻通信的基本原理,本人做通信快3年了,是我見過的介紹擴(kuò)頻通信最好的資料,分享一下!
    發(fā)表于 11-15 10:57

    C語言指針詳解

    ];//指針的類型是 int(*)[3] (5)int*(*ptr)[4];//指針的類型是int*(*)[4] 怎么樣?找出指針的類型的方法是不是很簡單? 完整的C
    發(fā)表于 07-04 03:34

    C指針詳解

    我想對很多學(xué)習(xí)C語言的新手來說,指針無疑是一個難點(diǎn)。但是,我覺得指針也是C語言特別重要的一個特性
    發(fā)表于 12-29 07:20

    c語言指針詳解

    1.指針簡介 指針C語言中廣泛使用的一種數(shù)據(jù)類型。 運(yùn)用指針編程是C
    發(fā)表于 03-26 09:51

    C語言指針電子教程

    本資料是一份不錯的關(guān)于C語言指針的電子教程,希望對大家有所幫助... 指針簡介 指針C
    發(fā)表于 07-30 16:00 ?77次下載

    C語言指針函數(shù)和函數(shù)指針詳細(xì)介紹

    C語言指針函數(shù)和函數(shù)指針詳細(xì)介紹。。。。。。。
    發(fā)表于 03-04 15:27 ?5次下載

    徹底搞定C語言指針詳解完整版

    徹底搞定C語言指針詳解完整版。
    發(fā)表于 05-10 17:04 ?0次下載

    C指針詳解-經(jīng)典-非常詳細(xì)

    C指針詳解-經(jīng)典-非常詳細(xì)
    發(fā)表于 10-23 17:39 ?79次下載
    <b class='flag-5'>C</b><b class='flag-5'>指針</b><b class='flag-5'>詳解</b>-經(jīng)典-非常詳細(xì)

    C語言的精髓——指針詳解

    C語言的精髓——指針詳解
    發(fā)表于 11-30 14:43 ?17次下載

    為什么C語言要引入指針_引入指針的好處是什么

    讓你知道什么是 C語言 指針,為什么用指針,從此不在害怕指針。
    的頭像 發(fā)表于 07-28 10:12 ?2.3w次閱讀

    C語言進(jìn)階】C語言指針的高階用法

    C語言進(jìn)階】C語言指針的高階用法
    的頭像 發(fā)表于 08-31 13:24 ?2625次閱讀

    底層解析C指針(一)

    指針C語言中的精髓部分,同樣也是C語言的難點(diǎn)所在,下面從最底層來分析
    的頭像 發(fā)表于 02-15 14:47 ?1043次閱讀
    <b class='flag-5'>底層</b>解析<b class='flag-5'>C</b><b class='flag-5'>指針</b>(一)

    c語言指針用法詳解:如何使用指針變量做函數(shù)參數(shù)

    指針C語言中一個比較重要的東西,有人說指針C語言的靈魂這句話說的一點(diǎn)也沒錯。 正確靈活地運(yùn)用
    發(fā)表于 09-21 12:32 ?1352次閱讀
    <b class='flag-5'>c</b><b class='flag-5'>語言</b><b class='flag-5'>指針</b>用法<b class='flag-5'>詳解</b>:如何使用<b class='flag-5'>指針</b>變量做函數(shù)參數(shù)

    C語言指針運(yùn)算符詳解

    C語言中,當(dāng)你有一個指向數(shù)組中某個元素的指針時,你可以對該指針執(zhí)行某些算術(shù)運(yùn)算,例如加法或減法。這些運(yùn)算可以用來遍歷數(shù)組中的元素,如ptr[i]等價于*(ptr + i)。然而,如果
    的頭像 發(fā)表于 10-30 11:16 ?574次閱讀

    C語言指針學(xué)習(xí)筆記

    本文從底層內(nèi)存分析,徹底讓讀者明白C語言指針的本質(zhì)。
    的頭像 發(fā)表于 11-05 17:40 ?530次閱讀
    <b class='flag-5'>C</b><b class='flag-5'>語言</b><b class='flag-5'>指針</b>學(xué)習(xí)筆記

    電子發(fā)燒友

    中國電子工程師最喜歡的網(wǎng)站

    • 2931785位工程師會員交流學(xué)習(xí)
    • 獲取您個性化的科技前沿技術(shù)信息
    • 參加活動獲取豐厚的禮品