1. 聲明指針

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

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

type *var-name;

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

以下是有效的指針聲明：

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

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

int *ip = NULL;

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

2. 獲取變量地址 &

2.1 & 作用于普通變量

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

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

3. 使用指針存儲地址

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

#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ù)類型，定義一個指針 *ip ，其中 ip 需要賦于一個地址(可以用 & 符號獲取其他變量的地址再賦值給 ip )，而 *ip 是一個具體的值，即讀取地址后獲得的值。

如果有合法的指針 p ，要訪問它包含的地址處存儲的值，可使用 *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;
}

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

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

5. sizeof() 用于指針

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

在特定的系統(tǒng)中，存儲地址所需的字節(jié)數(shù)是固定的。因此，將 sizeof( ) 用于指針時(shí)，結(jié)果取決于編譯程序時(shí)使用的編譯器和針對的操作系統(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é)，存儲指針?biāo)璧膬?nèi)存量都相同。

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

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

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

Type* Pointer = new Type;

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

Type* Pointer = new Type[numElements];

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

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

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

Type* Pointer = new Type; 
delete Pointer;

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

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

注意：

• 對于使用 new[…] 分配的內(nèi)存塊，需要使用 delete[] 來釋放；對于使用 new 為單個元素分配的內(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 指針

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

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

7.1 未初始化指針

下面這個代碼段說明了一個極為常見的錯誤 :

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

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

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

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

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

7.2 NULL指針

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

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

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

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

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

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

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

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

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

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

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

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

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

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

8. 指針運(yùn)算

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

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

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

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

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

ptr++

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

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

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

8.1 指針 ++ 和指針 - -

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

#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 指向兩個相關(guān)的變量，比如同一個數(shù)組中的不同元素，則可對 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ù)測的。對任何并非指向數(shù)組元素的指針執(zhí)行算術(shù)運(yùn)算是非法的 ( 但常常很難被檢測到 )。 如果一個指針減去一個整數(shù)后，運(yùn)算結(jié)果產(chǎn)生的指針?biāo)赶虻奈恢迷跀?shù)組第一個元素之前 , 那么它也是非法的。加法運(yùn)算稍有不同， 如果結(jié)果指針指向數(shù)組最后一個元素后面的那個內(nèi)存位置仍是合法 ( 但不能對這個指針執(zhí)行間接訪問操作 ) ， 不過再往后就不合法了。

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

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

警告總結(jié)：

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

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

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

聲明

int a[10];

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

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

int *pa;

則說明它是一個指向整型對象的指針，那么，賦值語句

pa = &a[0];

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

這樣，賦值語句

x = *pa；

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

如果 pa 指向數(shù)組中的某個特定元素，那么，根據(jù)指針運(yùn)算的定義，pa+1 將指向下一個元素，pa+i 將指向 pa 所指向數(shù)組元素之后的第 i 個元索，而 pa-i 將指向 pa 所指向數(shù)組元素之前的第 i 個元素。因此，如果指針 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ù)組長度是什么，上面的結(jié)論都成立。“指針加1”就意味著，pa+1 指向 pa 所指向的對象的下一個對象。相應(yīng)地，pa+i 指向 pa 所指向的對象之后的第 i 個對象。

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

pa = &a[0];

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

pa = a;

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

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

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

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

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

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

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

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

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

char s[];

和

char *s;

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

指針和數(shù)組是密切相關(guān)的。事實(shí)上，指針和數(shù)組在很多情況下是可以互換的。例如，一個指向數(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;    //編譯錯誤，因?yàn)関ar是數(shù)組名（也是數(shù)組首元素地址），不是一個變量，不可修改其值cout << *(var+i) << endl; //編譯正確，因?yàn)闆]有對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 是一個指向數(shù)組開頭的常量，不能作為左值。

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

*(var + 2) = 500;

10. 指針數(shù)組

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

int *ptr[MAX];

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

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

下面的實(shí)例用到了三個整數(shù)，它們將存儲在一個指針數(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)先級中， * 小于 [] ，所以 ptr 先和 [] 結(jié)合成為數(shù)組，然后再和 int * 結(jié)合形成數(shù)組的元素類型是 int * 類型，得到一個叫一個數(shù)組的元素是指針，簡稱指針數(shù)組。
這相當(dāng)于聲明了一個數(shù)組 ， 該數(shù)組有 3 個元素，其中每個元素都是一個指向整型對象的指針。

int *(ptr[3]);

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

11. 數(shù)組指針

int (*ptr)[3];

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

12. 指向指針的指針

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

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

int **var;

當(dāng)一個目標(biāo)值被一個指針間接指向到另一個指針時(shí)，訪問這個值需要使用兩個星號運(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ù)，只需要簡單地聲明函數(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)，必須聲明一個返回指針的函數(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 的，可確保變量的取值在整個生命周期內(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ù)不會修改指針指向的值。這可禁止程序員修改指針及其指向的數(shù)據(jù)。

16. 指針常見錯誤

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

16.1 內(nèi)存泄露

這可能是C++應(yīng)用程序最常見的問題之一：運(yùn)行時(shí)間越長，占用的內(nèi)存越多，系統(tǒng)越慢。如果在使用 new 動態(tài)分配的內(nèi)存不再需要后，程序員沒有使用配套的 delete 釋放，通常就會出現(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)算符 * 對指針解除引用，以訪問指向的值時(shí)，務(wù)必確保指針指向了有效的內(nèi)存單元，否則程序要么崩潰，要么行為不端。這看起來合乎邏輯，但一個非常常見的導(dǎo)致應(yīng)用程序崩潰的原因就是無效指針。

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

使用 delete 釋放后，任何有效指針都將無效。為了避免再次使用已經(jīng) delete 的指針，很多程序員在初始化指針或釋放指針后將其設(shè)置為 NULL ，并在使用運(yùn)算符 * 對指針解除引用前檢查它是否有效（將其與 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指针、指针运算、指针数组、数组指针、指针传递给函数、从函数返回指针）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

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