1. 聲明指針

指針是一個(gè)變量，其值為另一個(gè)變量的地址，即，內(nèi)存位置的直接地址。就像其他變量或常量一樣，您必須在使用指 針存儲(chǔ)其他變量地址之前，對(duì)其進(jìn)行聲明。

指針變量聲明的一般形式為：

type *var-name;

• type 是指針的基類型，它必須是一個(gè)有效的 C++ 數(shù)據(jù)類型；
• var-name 是指針變量的名稱。用來聲明指針的星號(hào) * 與乘法中使用的星號(hào)是相同的。但是，在這個(gè)語句中，星號(hào)是用來指定一個(gè)變量是指針。

以下是有效的指針聲明：

int    *ip;    /* 一個(gè)整型的指針 */
double *dp;    /* 一個(gè) double 型的指針 */
float  *fp;    /* 一個(gè)浮點(diǎn)型的指針 */
char   *ch;    /* 一個(gè)字符型的指針 */

與大多數(shù)變量一樣，除非對(duì)指針進(jìn)行初始化，否則它包含的值將是隨機(jī)的。您不希望訪問隨機(jī)的內(nèi)存地址，因此將指針初始化為 NULL 。 NULL 是一個(gè)可以檢查的值，且不會(huì)是內(nèi)存地址：

int *ip = NULL;

未初始化的指針可能導(dǎo)致程序訪問非法內(nèi)存單元，進(jìn)而導(dǎo)致程序崩潰。

2. 獲取變量地址 &

2.1 & 作用于普通變量

每一個(gè)變量都有一個(gè)內(nèi)存位置，每一個(gè)內(nèi)存位置都定義了 & 運(yùn)算符訪問的地址，它表示了在內(nèi)存中的一個(gè)地址。

#include <iostream>
using namespace std;int main ()
{int  a;char b[10];cout << &a << endl;	// 0x7ffe06ed398ccout << &b << endl;	// 0x7ffe06ed3990return 0;
}

2.1 & 作用于數(shù)組

short int height[10]; //int型的數(shù)組（short int 每個(gè)數(shù)據(jù)2字節(jié)）
cout <<  "height       "<< height << endl <<  "height+1     "<< height + 1 << endl<<  "&height[0]   " <<  &height[0] << endl<<  "&height+1    "<< &height + 1<< endl<<  "height+9     "<< height+9 << endl<< "height+10    " << height + 10 << endl;

輸出結(jié)果：

height       0x7fffce72dfc0
height+1     0x7fffce72dfc2
&height[0]   0x7fffce72dfc0
&height+1    0x7fffce72dfd4
height+9     0x7fffce72dfd2
height+10    0x7fffce72dfd4

• 數(shù)組名 height 表示數(shù)組首元素地址；
• 數(shù)組名 height+1 表示數(shù)組第二個(gè)元素地址；
• &height[0] 表示數(shù)組首個(gè)元素的地址，其與 height 是相等的；
• &height+1 表示先取數(shù)組開始的地址，然后再加 1 ，也就是說 c0 + 10*2 ，表示成 16 進(jìn)制為 c0+14=d4；
• height+9 表示數(shù)組最后一個(gè)元素，c0+9*2= c0+12=d2；
• height+10 表示整個(gè)數(shù)組結(jié)束之后的第一個(gè)地址，與 &height+1 相等；

3. 使用指針存儲(chǔ)地址

知道如何聲明指針以及如何獲取變量的地址，還知道指針是用于存儲(chǔ)內(nèi)存地址的變量。現(xiàn)在將它們聯(lián)系起來，使用指針來存儲(chǔ)用 & 獲取的地址。

#include <iostream>
using namespace std;int main ()
{int age = 10;int *page = &age;cout << "age address is " << &age << endl;   // 0x7ffc43a7b75ccout << "page is " << page << endl;  // 0x7ffc43a7b75cint dogAge = 3;page = &dogAge;  // 將不同的內(nèi)存地址賦給指針變量，讓它指向不同的值cout << "page is " << page << endl;  // 0x7ffef77b240creturn 0;
}

4. 使用 * 訪問指針指向的數(shù)據(jù)

指針的本質(zhì)是變量，可以是各種數(shù)據(jù)類型，定義一個(gè)指針 *ip ，其中 ip 需要賦于一個(gè)地址(可以用 & 符號(hào)獲取其他變量的地址再賦值給 ip )，而 *ip 是一個(gè)具體的值，即讀取地址后獲得的值。

如果有合法的指針 p ，要訪問它包含的地址處存儲(chǔ)的值，可使用 *p 。

#include <iostream>
using namespace std;int main ()
{int age = 10;int *page = &age;cout << "age address is " << &age << endl;   // 0x7ffc43a7b75ccout << "page is " << page << endl;  // 0x7ffc43a7b75ccout << "page point value is " << *page << endl; // 10int dogAge = 3;page = &dogAge;  // 將不同的內(nèi)存地址賦給指針變量，讓它指向不同的值cout << "page is " << page << endl;  // 0x7ffef77b240ccout << "page point value is " << *page << endl; // 3return 0;
}

• & 符號(hào)的意思是取地址，也就是返回一個(gè)對(duì)象在內(nèi)存中的地址。
• * 符號(hào)的意思是取得一個(gè)指針?biāo)赶虻膶?duì)象。 也就是如果一個(gè)指針保存著一個(gè)內(nèi)存地址，那么它就返回在那個(gè)地址的對(duì)象。

簡(jiǎn)單點(diǎn)就是： & 是取址， * 是取值。

5. sizeof() 用于指針

指針是包含內(nèi)存地址的變量。因此無論指針指向哪種類型的變量（整型、浮點(diǎn)型、字符型，還是其他的數(shù)據(jù)類型），其內(nèi)容都是一個(gè)地址（一個(gè)代表內(nèi)存地址的長(zhǎng)的十六進(jìn)制數(shù)）。

在特定的系統(tǒng)中，存儲(chǔ)地址所需的字節(jié)數(shù)是固定的。因此，將 sizeof( ) 用于指針時(shí)，結(jié)果取決于編譯程序時(shí)使用的編譯器和針對(duì)的操作系統(tǒng)，與指針指向的變量類型無關(guān)。

不同數(shù)據(jù)類型的指針之間唯一的不同是，指針?biāo)赶虻淖兞炕虺Ａ康臄?shù)據(jù)類型不同。

#include <iostream>
using namespace std;int main ()
{cout << "sizeof(char) = " << sizeof(char) << endl;cout << "sizeof(int) = " << sizeof(int) << endl;cout << "sizeof(double) = " << sizeof(double) << endl;cout << "sizeof(*char) = " << sizeof(char *) << endl;cout << "sizeof(*int) = " << sizeof(int *) << endl;cout << "sizeof(*double) = " << sizeof(double *) << endl;return 0;
}

輸出結(jié)果：

sizeof(char) = 1
sizeof(int) = 4
sizeof(double) = 8
sizeof(*char) = 8
sizeof(*int) = 8
sizeof(*double) = 8

輸出表明，雖然 sizeof(char) 為 1 字節(jié)，而 sizeof(double) 為 8 字節(jié)，但 sizeof(char*) 和 sizeof(double*) 都是 8 字節(jié)。這是因?yàn)椴还苤羔樦赶虻膬?nèi)存單元是 1 字節(jié)還是 8 字節(jié)，存儲(chǔ)指針?biāo)璧膬?nèi)存量都相同。

備注：使用的是 64 位編譯器，并在 64 位系統(tǒng)上運(yùn)行該程序，可能發(fā)現(xiàn)將 sizeof 用于指針的結(jié)果為 64 位，即 8 字節(jié)。

6. 使用 new 和 delete 動(dòng)態(tài)地分配和釋放內(nèi)存

使用 new 來分配新的內(nèi)存塊。通常情況下，如果成功， new 將返回指向一個(gè)指針，指向分配的內(nèi)存，否則將引發(fā)異常。使用 new 時(shí)，需要指定要為哪種數(shù)據(jù)類型分配內(nèi)存：

Type* Pointer = new Type;

需要為多個(gè)元素分配內(nèi)存時(shí)，還可指定要為多少個(gè)元素分配內(nèi)存：

Type* Pointer = new Type[numElements];

因此，如果需要給整型分配內(nèi)存，可使用如下語法：

int* pointToAnInt = new int; 
int* pointToNums = new int[10];

使用 new 分配的內(nèi)存最終都需使用對(duì)應(yīng)的 delete 進(jìn)行釋放：

Type* Pointer = new Type; 
delete Pointer;

這種規(guī)則也適用于為多個(gè)元素分配的內(nèi)存：

Type* Pointer = new Type[numElements]; 
delete[] Pointer; 

注意：

• 對(duì)于使用 new[…] 分配的內(nèi)存塊，需要使用 delete[] 來釋放；對(duì)于使用 new 為單個(gè)元素分配的內(nèi)存，需要使用 delete 來釋放。
• 不能將運(yùn)算符 delete 用于任何包含地址的指針，而只能用于 new 返回的且未使用 delete 釋放的指針。

#include <iostream>
using namespace std;int main ()
{int *a = new int;*a = 10;cout << "a is " << a << " *a is " << *a << endl;int *b = new int[10];cout << "b is " << b << " *b is " << *b << endl;delete a;delete[] b;return 0;
}

7. 未初始化指針、NULL 指針

聲明一個(gè)指針變量并不會(huì)自動(dòng)分配任何內(nèi)存。在對(duì)指針執(zhí)行間接訪問前 , 指針必須進(jìn)行初始化、或者使它指向現(xiàn)有的內(nèi)存、或者給它分配動(dòng)態(tài)內(nèi)存。

對(duì)未初始化的指針變量執(zhí)行間接訪問操作是非法的，而且這種錯(cuò)誤常常難以檢測(cè)。其結(jié)果常常是一個(gè)不相關(guān)的值被修改。這種錯(cuò)誤是很難被調(diào)試發(fā)現(xiàn)的。

7.1 未初始化指針

下面這個(gè)代碼段說明了一個(gè)極為常見的錯(cuò)誤 :

int main() 
{int *a;*a = 10;cout << *a << endl;return 0;
}

這個(gè)聲明創(chuàng)建了一個(gè)名叫 a 的指針變量 , 后面那條賦值語句把 12 存儲(chǔ)在 a 所指向的內(nèi)存位置 。但是究竟 a 指向哪里呢 ? 我們聲明了這個(gè)變量 , 但從未對(duì)它進(jìn)行初始化, 所以我們沒有辦法預(yù)測(cè) 12 這個(gè)值將存儲(chǔ)于什么地方 。

聲明一個(gè)指向整型的指針不會(huì) “ 創(chuàng)建 ” 用于存儲(chǔ)整型值的內(nèi)存空間 。

所以 , 如果程序執(zhí)行這個(gè)賦值操作 , 會(huì)發(fā)生什么情況呢 ? 如果你運(yùn)氣好, a 的初始值會(huì)是個(gè)非法地址 , 這樣賦值語句將會(huì)出錯(cuò) , 從而終止程序 。 在 UNIX 系統(tǒng)上 , 這個(gè)錯(cuò)誤被稱為 “ 段違例( Segmentation fault (core dumped) ) ” 或 “ 內(nèi)存錯(cuò)誤 ( memory fault ) ” 。 它提示程序試圖訪問一個(gè)并未分配給程序的內(nèi)存位置 。

所以，在你對(duì)指針進(jìn)行間接訪問之前，必須非常小心，確保它們已被初始化 !

7.2 NULL指針

標(biāo)準(zhǔn)定義了 NULL 指針，它作為一個(gè)特殊的指針變量 ，表示不指向任何東西。要使一個(gè)指針變量為 NULL , 你可以給它賦一個(gè)零值 。 為了測(cè)試一個(gè)指針變量是否為 NULL ，你可以將它與零值進(jìn)行比較。

之所以選擇零這個(gè)值是因?yàn)橐环N源代碼約定 。 就機(jī)器內(nèi)部而言 ，NULL 指針的實(shí)際值可能與此不同 。在這種情況下 ，編譯器將負(fù)責(zé)零值和內(nèi)部值之間的翻譯轉(zhuǎn)換 。

在變量聲明的時(shí)候，如果沒有確切的地址可以賦值，為指針變量賦一個(gè) NULL 值是一個(gè)良好的編程習(xí)慣。賦為 NULL 值的指針被稱為空指針。

在大多數(shù)的操作系統(tǒng)上，程序不允許訪問地址為 0 的內(nèi)存，因?yàn)樵搩?nèi)存是操作系統(tǒng)保留的。然而，內(nèi)存地址 0 有特別重要的意義，它表明該指針不指向一個(gè)可訪問的內(nèi)存位置。

通過一個(gè)指針訪問它所指向的地址的過程稱為間接訪問 (indirection) 或解引用指針 (dereferencing
thepointer) 。 這個(gè)用于執(zhí)行間接訪問的操作符是單目操作符 *

對(duì)指針進(jìn)行解引用操作可以獲得它所指向的值。但從定義上看， NULL 指針并未指向任何東西。因此，對(duì)一個(gè) NULL 指針進(jìn)行解引用操作是非法的。在對(duì)指針進(jìn)行解引用操作之前，你首先必須確保它并非 NULL 指針 。

int main() 
{int *a = NULL;cout << *a << endl;return 0;
}

程序會(huì)報(bào)錯(cuò)：Segmentation fault (core dumped)。

NULL 指針是一個(gè)定義在標(biāo)準(zhǔn)庫中的值為零的常量。請(qǐng)看下面的程序：

#include <iostream>
using namespace std;int main ()
{int *a = NULL;cout << " a is " << a << endl; //  a is 0return 0;
}

內(nèi)存地址 0 有特別重要的意義，它表明該指針不指向一個(gè)可訪問的內(nèi)存位置。但按照慣例，如果指針包含空值（零值），則假定它不指向任何東西。

如需檢查一個(gè)空指針，可以使用 if 語句，如下所示：

if(ptr)     /* 如果 ptr 非空，則完成 */
if(!ptr)    /* 如果 ptr 為空，則完成 */

NULL 指針就是不指向任何東西的指針。它可以賦值給一個(gè)指針，用于表示那個(gè)指針并不指向任何值 。 對(duì) NULL 指針執(zhí)行間接訪問操作的后果因編譯器而異，兩個(gè)常見的后果分別是返回內(nèi)存位置零的值以及終止程序 。

8. 指針運(yùn)算

有效的指針運(yùn)算包括

• 相同類型指針之間的賦值運(yùn)算 ;
• 指針同整數(shù)之間的加法或減法運(yùn)算 ;
• 指向相同數(shù)組中元素的兩個(gè)指針間的減法或比較運(yùn)算 ;
• 將指針賦值為 0 或指針與 0 之間的比較運(yùn)算 。

其他所有形式的指針運(yùn)算都是非法的 , 例如

• 兩個(gè)指針間的加法 、 乘法 、除法 、 移位或屏蔽運(yùn)算 ;
• 指針同 float 或 double 類型之間的加法運(yùn)算 ;
• 不經(jīng)強(qiáng)制類型轉(zhuǎn)換而直接將指向一種類型對(duì)象的指針賦值給指向另一種類型對(duì)象的指針的運(yùn)算 ( 兩個(gè)指針之一是 void* 類型的情況除外 )。

可以對(duì)指針執(zhí)行算術(shù)運(yùn)算。可以對(duì)指針進(jìn)行四種算術(shù)運(yùn)算： ++ 、 -- 、 + 、 - 。
假設(shè) ptr 是一個(gè)指向地址 1000 的整型指針，是一個(gè) 32 位的整數(shù)，對(duì)該指針執(zhí)行下列的算術(shù)運(yùn)算：

ptr++

在執(zhí)行完上述的運(yùn)算之后， ptr 將指向位置 1004，因?yàn)?ptr 每增加一次，它都將指向下一個(gè)整數(shù)位置，即當(dāng)前位置往后移 4 個(gè)字節(jié)。這個(gè)運(yùn)算會(huì)在不影響內(nèi)存位置中實(shí)際值的情況下，移動(dòng)指針到下一個(gè)內(nèi)存位置。

如果 ptr 指向一個(gè)地址為 1000 的字符，上面的運(yùn)算會(huì)導(dǎo)致指針指向位置 1001，因?yàn)橄乱粋€(gè)字符位置是在 1001。

在指針值上可以執(zhí)行一些有限的算術(shù)運(yùn)算。你可以把一個(gè)整型值加到一個(gè)指針上，也可以從一個(gè)指針減去一個(gè)整型值 。在這兩種情況下 ，這個(gè)整型值會(huì)進(jìn)行調(diào)整，原值將乘以指針目標(biāo)類型的長(zhǎng)度 。這樣，對(duì)一個(gè)指針加 1 將使它指向下一個(gè)變量 , 至于該變量在內(nèi)存中占兒個(gè)字節(jié)的大小則與此無關(guān)。

8.1 指針 ++ 和指針 - -

我們喜歡在程序中使用指針代替數(shù)組，因?yàn)樽兞恐羔樋梢赃f增，而數(shù)組不能遞增，因?yàn)閿?shù)組是一個(gè)常量指針。

#include <iostream>
using namespace std;int main ()
{int a[3] = {1,2,3};int *p = a;for(int i=0; i<3; i++){cout << " *p " << *p << endl; p++;}cout << "#################" << endl;int *q = &a[2];for(int i=2; i>=0; i--){cout << " *q " << *q << endl; q--;}return 0;
}

輸出結(jié)果：

 *p 1*p 2*p 3
#################*q 3*q 2*q 1

8.2 指針比較

指針可以用關(guān)系運(yùn)算符進(jìn)行比較，如 == 、 < 和 > 。如果 p1 和 p2 指向兩個(gè)相關(guān)的變量，比如同一個(gè)數(shù)組中的不同元素，則可對(duì) p1 和 p2 進(jìn)行大小比較。

#include <iostream>
using namespace std;int main ()
{int a[3] = {1,2,3};int *p = a;int *q = &a[2];while (p<=q){if (p==q){cout << "p==q: *p is " << *p << " *q is " << *q << endl;}if (p<q){cout << "p<q: *p is " << *p << " *q is " << *q << endl;}if (p>q){cout << "p>q: *p is " << *p << " *q is " << *q << endl;}p++;q--;}return 0;
}

輸出：

p<q: *p is 1 *q is 3
p==q: *p is 2 *q is 2

然而 , 指針運(yùn)算只有作用于數(shù)組中其結(jié)果才是可以預(yù)測(cè)的。對(duì)任何并非指向數(shù)組元素的指針執(zhí)行算術(shù)運(yùn)算是非法的 ( 但常常很難被檢測(cè)到 )。 如果一個(gè)指針減去一個(gè)整數(shù)后，運(yùn)算結(jié)果產(chǎn)生的指針?biāo)赶虻奈恢迷跀?shù)組第一個(gè)元素之前 , 那么它也是非法的。加法運(yùn)算稍有不同， 如果結(jié)果指針指向數(shù)組最后一個(gè)元素后面的那個(gè)內(nèi)存位置仍是合法 ( 但不能對(duì)這個(gè)指針執(zhí)行間接訪問操作 ) ， 不過再往后就不合法了。

如果兩個(gè)指針都指向同一個(gè)數(shù)組中的元素 , 那么它們之間可以相減 。 指針減法的結(jié)果經(jīng)過調(diào)整( 除以數(shù)組元素類型的長(zhǎng)度 )， 表示兩個(gè)指針在數(shù)組中相隔多少個(gè)元素。如果兩個(gè)指針并不是指向同一個(gè)數(shù)組的元素，那么它們之間進(jìn)行相減就是錯(cuò)誤的 。

任何指針之間都可以進(jìn)行比較， 測(cè)試它們相等或不相等 。如果兩個(gè)指針都指向同一個(gè)數(shù)組中的元素，那么它們之間還可以執(zhí)行 < 、 < = 、 > 和 > = 等關(guān)系運(yùn)算 ，用于判斷它們?cè)跀?shù)組中的相對(duì)位置。 對(duì)兩個(gè)不相關(guān)的指針執(zhí)行關(guān)系運(yùn)算，其結(jié)果是未定義的 。

警告總結(jié)：

• 錯(cuò)誤地對(duì)一個(gè)未初始化的指針變量進(jìn)行解引用。
• 錯(cuò)誤地對(duì)一個(gè) NULL 指針進(jìn)行解引用 。
• 向函數(shù)錯(cuò)誤地傳遞 NULL 指針。
• 未檢測(cè)到指針表達(dá)式的錯(cuò)誤，從而導(dǎo)致不可預(yù)料的結(jié)果 。
• 對(duì)一個(gè)指針進(jìn)行減法運(yùn)算，使它非法地指向了數(shù)組第 1 個(gè)元素的前面的內(nèi)存位置。

如果指針并不指向任何有意義的東西 ，就把它設(shè)置為 NULL 。

9. 指針作用于數(shù)組

聲明

int a[10];

定義了一個(gè)長(zhǎng)度為 10 的數(shù)組 a 。換句話說，它定義了一個(gè)由 10 個(gè)對(duì)象組成的集合，這 10 個(gè)對(duì)象
存儲(chǔ)在相鄰的內(nèi)存區(qū)域中，名字分別為a[0] 、a[1] 、… a[9] 。

a[i] 表示該數(shù)組的第 i 個(gè)元素。如果 pa 的聲明為

int *pa;

則說明它是一個(gè)指向整型對(duì)象的指針，那么，賦值語句

pa = &a[0];

則可以將指針 pa 指向數(shù)組 a 的第 0 個(gè)元素， 也就是說，pa 的值為數(shù)組元素 a[0] 的地址。

這樣，賦值語句

x = *pa；

將把數(shù)組元素 a[0] 中的內(nèi)容復(fù)制到變量 x 中。

如果 pa 指向數(shù)組中的某個(gè)特定元素，那么，根據(jù)指針運(yùn)算的定義，pa+1 將指向下一個(gè)元素，pa+i 將指向 pa 所指向數(shù)組元素之后的第 i 個(gè)元索，而 pa-i 將指向 pa 所指向數(shù)組元素之前的第 i 個(gè)元素。因此，如果指針 pa 指向 a[0] , 那么 *( pa+i) 引用的是數(shù)組元素 a[i] 的內(nèi)容，pa+i 是數(shù)組元素 a[i] 的地址，*(pa+i) 引用的是數(shù)組元素 a[i] 的內(nèi)容。

無論數(shù)組 a 中元素的類型或數(shù)組長(zhǎng)度是什么，上面的結(jié)論都成立。“指針加1”就意味著，pa+1 指向 pa 所指向的對(duì)象的下一個(gè)對(duì)象。相應(yīng)地，pa+i 指向 pa 所指向的對(duì)象之后的第 i 個(gè)對(duì)象。

下標(biāo)和指針運(yùn)算之間具有密切的對(duì)應(yīng)關(guān)系。根據(jù)定義，數(shù)組類型的變量或表達(dá)式的值是該數(shù)組第 0 個(gè)元素的地址。執(zhí)行賦值語

pa = &a[0];

后，pa 和 a 具有相同的值。因?yàn)閿?shù)組名所代表的就是該數(shù)組最開始的一個(gè)元素的地址，所以，
賦值語句 pa=&a[0] 也可以寫成下列形式：

pa = a;

對(duì)數(shù)組元素 a[i] 的引用也可以寫成 *( a+i) 這種形式。對(duì)第一次接觸這種寫法的人來說，可能會(huì)覺得很奇怪。在計(jì)算數(shù)組元素 a[i] 的值時(shí)，C++ 語言實(shí)際上先將其轉(zhuǎn)換為 *( a+i) 的形式，然后再進(jìn)行求值，因此在程序中這兩種形式是等價(jià)的。

如果對(duì)這兩種等價(jià)的表示形式分別施加地址運(yùn)算符 & , 便可以得出這樣的結(jié)論：&a[i] 和 a+i 的含義也是相同的。a+i 是 a 之后第 i 個(gè)元素的地址。相應(yīng)地，如果 pa 是一個(gè)指針，那么，在表達(dá)式中也可以在它的后面加下標(biāo) pa[i] 與 *(pa+i) 是等價(jià)的。簡(jiǎn)而言之，一個(gè)通過數(shù)組和下標(biāo)實(shí)現(xiàn)的表達(dá)式可等價(jià)地通過指針和偏移量實(shí)現(xiàn)。

但是，我們必須記住，數(shù)組名和指針之間有一個(gè)不同之處。指針是一個(gè)變量，因此，在 C/C++ 語言中，語句 pa=a 和 pa++ 都是合法的。但數(shù)組名不是變量，因此，類似于 a=pa 和 a++ 形式的語句是非法的。

當(dāng)把數(shù)組名傳遞給一個(gè)函數(shù)時(shí)，實(shí)際上傳遞的是該數(shù)組第一個(gè)元素的地址。在被調(diào)用函數(shù)中，該參數(shù)是一個(gè)局部變量，因此，數(shù)組名參數(shù)必須是一個(gè)指針，也就是一個(gè)存儲(chǔ)地址值的變量。我們可以利用該特性編寫strlen 函數(shù)的另一個(gè)版本，該函數(shù)用于計(jì)算一個(gè)字符串的長(zhǎng)度。

int strlen(char *s)
{for(int n=0; *s ！= '\0'; s++){n++;}return n;
}

因?yàn)?s 是一個(gè)指針，所以對(duì)其執(zhí)行自增運(yùn)算是合法的。執(zhí)行 s++ 運(yùn)算不會(huì)影響到 strlen 函數(shù)的調(diào)用者中的字符串， 它僅對(duì)該指針在 strlen 函數(shù)中的私有副本進(jìn)行自增運(yùn)算。因此，類似于下面這樣的函數(shù)調(diào)用：

strlen("hello, world"); 	/*字符串常量*/
strlen(array);				/*字符數(shù)組array有100個(gè)元素*/
strlen(ptr);				/* Ptr是一個(gè)指向char *類型對(duì)象的指針 */

都可以正確地執(zhí)行。

在函數(shù)定義中，形式參數(shù)

char s[];

和

char *s;

是等價(jià)的。我們通常更習(xí)慣于使用后一種形式， 因?yàn)樗惹罢吒庇^地表明了該參數(shù)是一個(gè)指針。

指針和數(shù)組是密切相關(guān)的。事實(shí)上，指針和數(shù)組在很多情況下是可以互換的。例如，一個(gè)指向數(shù)組開頭的指針，可以通過使用指針的算術(shù)運(yùn)算或數(shù)組索引來訪問數(shù)組。

#include <iostream>
using namespace std;int main ()
{int var[3] = {10,100,200};int *p=var;for (int i = 0; i < 3; i++){//cout << *(var++) << endl;    //編譯錯(cuò)誤，因?yàn)関ar是數(shù)組名（也是數(shù)組首元素地址），不是一個(gè)變量，不可修改其值cout << *(var+i) << endl; //編譯正確，因?yàn)闆]有對(duì)var進(jìn)行賦值，只是通過與i相加訪問變量地址cout<<  *(p++)<<endl;        ///編譯正確，p為指針變量可賦值}return 0;
}

輸出結(jié)果：

10
10
100
100
200
200

把指針運(yùn)算符 * 應(yīng)用到 var 上是完全可以的，但修改 var 的值是非法的。這是因?yàn)?var 是一個(gè)指向數(shù)組開頭的常量，不能作為左值。

由于一個(gè)數(shù)組名對(duì)應(yīng)一個(gè)指針常量，只要不改變數(shù)組的值，仍然可以用指針形式的表達(dá)式。例如，下面是一個(gè)有效的語句，把 var[2] 賦值為 500：

*(var + 2) = 500;

10. 指針數(shù)組

可能有一種情況，我們想要讓數(shù)組存儲(chǔ)指向 int 或 char 或其他數(shù)據(jù)類型的指針。下面是一個(gè)指向整數(shù)的指針數(shù)組的聲明：

int *ptr[MAX];

在這里，把 ptr 聲明為一個(gè)數(shù)組，由 MAX 個(gè)整數(shù)指針組成。因此， ptr 中的每個(gè)元素，都是一個(gè)指向 int 值的指針。

char *names[MAX] 是指針數(shù)組，它的本質(zhì)是存儲(chǔ)指針的數(shù)組，即存儲(chǔ) char 類型的指針的數(shù)組，數(shù)組內(nèi)的每個(gè)元素都是一個(gè)指針，并且指向一個(gè)存儲(chǔ) char 類型的地址。

下面的實(shí)例用到了三個(gè)整數(shù)，它們將存儲(chǔ)在一個(gè)指針數(shù)組中，如下所示

#include <iostream>using namespace std;
const int MAX = 3;int main ()
{int  var[MAX] = {10, 100, 200};int *ptr[MAX];for (int i = 0; i < MAX; i++){ptr[i] = &var[i]; // 賦值為整數(shù)的地址}for (int i = 0; i < MAX; i++){cout << "Value of var[" << i << "] = ";cout << *ptr[i] << endl;}return 0;
}

輸出結(jié)果：

Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

詳解指針數(shù)組的結(jié)合過程：

int *ptr[3];

由于 C++ 運(yùn)算符的優(yōu)先級(jí)中， * 小于 [] ，所以 ptr 先和 [] 結(jié)合成為數(shù)組，然后再和 int * 結(jié)合形成數(shù)組的元素類型是 int * 類型，得到一個(gè)叫一個(gè)數(shù)組的元素是指針，簡(jiǎn)稱指針數(shù)組。
這相當(dāng)于聲明了一個(gè)數(shù)組 ， 該數(shù)組有 3 個(gè)元素，其中每個(gè)元素都是一個(gè)指向整型對(duì)象的指針。

int *(ptr[3]);

這個(gè)和上面的一樣，優(yōu)先級(jí)順序是 * 小于 () ， () 等于 [] 。 ptr 先和 [] 結(jié)合成為數(shù)組，然后再和 int * 結(jié)合形成數(shù)組的元素類型是 int * 類型，得到一個(gè)叫一個(gè)數(shù)組的元素是指針，簡(jiǎn)稱指針數(shù)組。

11. 數(shù)組指針

int (*ptr)[3];

這個(gè)就不一樣了，優(yōu)先級(jí)順序是 * 小于 () ， () 等于 [] ， () 和 [] 的優(yōu)先級(jí)一樣，但是結(jié)合順序是從左到右，所以先是 () 里的 * 和 ptr 結(jié)合成為一個(gè)指針，然后是 (*ptr) 和 [] 相結(jié)合成為一個(gè)數(shù)組，最后叫一個(gè)指針 ptr 指向一個(gè)數(shù)組，簡(jiǎn)稱數(shù)組指針。

12. 指向指針的指針

指向指針的指針是一種多級(jí)間接尋址的形式，或者說是一個(gè)指針鏈。通常，一個(gè)指針包含一個(gè)變量的地址。當(dāng)我們定義一個(gè)指向指針的指針時(shí)，第一個(gè)指針包含了第二個(gè)指針的地址，第二個(gè)指針指向包含實(shí)際值的位置。

一個(gè)指向指針的指針變量必須如下聲明，即在變量名前放置兩個(gè)星號(hào)。例如，下面聲明了一個(gè)指向 int 類型指針的指針：

int **var;

當(dāng)一個(gè)目標(biāo)值被一個(gè)指針間接指向到另一個(gè)指針時(shí)，訪問這個(gè)值需要使用兩個(gè)星號(hào)運(yùn)算符，如下面實(shí)例所示：

#include <iostream>
using namespace std;int main ()
{int  var;int  *ptr;int  **pptr;var = 3000;// 獲取 var 的地址ptr = &var;// 使用運(yùn)算符 & 獲取 ptr 的地址pptr = &ptr;// 使用 pptr 獲取值cout << "var 值為 :" << var << endl;cout << "*ptr 值為:" << *ptr << endl;cout << "**pptr 值為:" << **pptr << endl;return 0;
}

輸出結(jié)果：

var 值為 :3000
*ptr 值為:3000
**pptr 值為:3000

13. 傳遞指針給函數(shù)

C++ 允許您傳遞指針給函數(shù)，只需要簡(jiǎn)單地聲明函數(shù)參數(shù)為指針類型即可。

#include <iostream>
using namespace std;int get(int *p);int main ()
{int a = 1;cout << "a 值為 :" << a << endl;cout << "&a = " << &a << endl;get(&a);cout << "a 值為 :" << a << endl; return 0;
}int get(int *p)
{cout << "p = " << p << endl;*p = 10;return *p;
}

輸出結(jié)果：

a 值為 :1
&a = 0x7ffcb10db964
p = 0x7ffcb10db964
a 值為 :10

14. 從函數(shù)返回指針

C++ 允許從函數(shù)返回指針。為了做到這點(diǎn)，必須聲明一個(gè)返回指針的函數(shù)，如下所示：

int * func();

另外，C++ 不支持在函數(shù)外返回局部變量的地址，除非定義局部變量為 static 變量。

#include <iostream>
using namespace std;int * get();int main ()
{int * ret=NULL;ret = get();for(int i=0; i<3; i++){   cout << "&ret is " << ret << endl;cout << "i is " << i << " value is " << *ret << endl;ret++;}return 0;
}int * get()
{static int a[3] = {1,2,3};return a;
}

輸出結(jié)果：

&ret is 0x601070
i is 0 value is 1
&ret is 0x601074
i is 1 value is 2
&ret is 0x601078
i is 2 value is 3

15 const 用于指針

通過將變量聲明為 const 的，可確保變量的取值在整個(gè)生命周期內(nèi)都固定為初始值。這種變量的值不能修改，因此不能將其用作左值。

指針也是變量，因此也可將關(guān)鍵字 const 用于指針。然而，指針是特殊的變量，包含內(nèi)存地址，還可用于修改內(nèi)存中的數(shù)據(jù)塊。因此， const 指針有如下三種。

• 指針包含的地址是常量，不能修改，但可修改指針指向的數(shù)據(jù)：

int daysInMonth = 30;
int* const pDaysInMonth = &daysInMonth;
*pDaysInMonth = 31; // OK! Data pointed to can be changed
int daysInLunarMonth = 28;
pDaysInMonth = &daysInLunarMonth; // Not OK! Cannot change address!

• 指針指向的數(shù)據(jù)為常量，不能修改，但可以修改指針包含的地址，即指針可以指向其他地方：

int hoursInDay = 24;
const int* pointsToInt = &hoursInDay;
int monthsInYear = 12;
pointsToInt = &monthsInYear; // OK!
*pointsToInt = 13; // Not OK! Cannot change data being pointed to
int* newPointer = pointsToInt; // Not OK! Cannot assign const to non-const

• 指針包含的地址以及它指向的值都是常量，不能修改（這種組合最嚴(yán)格）：

int hoursInDay = 24;
const int* const pHoursInDay = &hoursInDay;
*pHoursInDay = 25; // Not OK! Cannot change data being pointed to
int daysInMonth = 30;
pHoursInDay = &daysInMonth; // Not OK! Cannot change address

將指針傳遞給函數(shù)時(shí)，這些形式的 const 很有用。函數(shù)參數(shù)應(yīng)聲明為最嚴(yán)格的 const 指針，以確保函數(shù)不會(huì)修改指針指向的值。這可禁止程序員修改指針及其指向的數(shù)據(jù)。

16. 指針常見錯(cuò)誤

C++沒有自動(dòng)垃圾收集器對(duì)程序已分配但不能使用的內(nèi)存進(jìn)行清理。使用指針來管理內(nèi)存資源時(shí)，程序員很容易犯錯(cuò)。

16.1 內(nèi)存泄露

這可能是C++應(yīng)用程序最常見的問題之一：運(yùn)行時(shí)間越長(zhǎng)，占用的內(nèi)存越多，系統(tǒng)越慢。如果在使用 new 動(dòng)態(tài)分配的內(nèi)存不再需要后，程序員沒有使用配套的 delete 釋放，通常就會(huì)出現(xiàn)這種情況。

確保應(yīng)用程序釋放其分配的所有內(nèi)存是程序員的職責(zé)。絕不能讓下面這樣的情形發(fā)生：

int* a = new int[5]; // initial allocation
// use a
...
// forget to release using delete[] a;
...
// make another allocation and overwrite
a = new int[10]; // leaks the previously allocated memory

16.2 指針指向無效的內(nèi)存單元

使用運(yùn)算符 * 對(duì)指針解除引用，以訪問指向的值時(shí)，務(wù)必確保指針指向了有效的內(nèi)存單元，否則程序要么崩潰，要么行為不端。這看起來合乎邏輯，但一個(gè)非常常見的導(dǎo)致應(yīng)用程序崩潰的原因就是無效指針。

16.3 懸浮指針（也叫迷途或失控指針）

使用 delete 釋放后，任何有效指針都將無效。為了避免再次使用已經(jīng) delete 的指針，很多程序員在初始化指針或釋放指針后將其設(shè)置為 NULL ，并在使用運(yùn)算符 * 對(duì)指針解除引用前檢查它是否有效（將其與 NULL 比較）。

#include <iostream>
using namespace std;int main ()
{int *a = NULL;cout <<a << endl;	// 0if(a){cout <<"valid" << endl;}else{cout <<"invalid" << endl;	// invalid}return 0;
}

參考：
https://www.runoob.com/w3cnote/c-constant-pointer.html

總結(jié)

以上是生活随笔為你收集整理的C++ 笔记（14）— 指针（指针声明、取地址、取值、new/delete、NULL指针、指针运算、指针数组、数组指针、指针传递给函数、从函数返回指针）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。