1. 指向常量的指針和常量指針

2. 指向指針的指針

1. 指向常量的指針和常量指針

       往往有c++程序員說(shuō)“常量指針”（const pointer）時(shí)，其想表達(dá)的意思往往是“指向常量的指針”（pointer to const），但實(shí)際上，這兩者是兩個(gè)完全不同的概念。

T *pt = new T;   // 一個(gè)指向T的指針
const T *pct = pt; // 一個(gè)指向const T的指針
T *const cpt = pt; // 一個(gè)const指針，指向T

       將const修飾符放到指針聲明之前，應(yīng)該想好，到底想讓什么東西變成常量，是指針？還是準(zhǔn)備指向的那個(gè)對(duì)象？或兼而有之？在pct的聲明中，指針不是const的，但它所指向的對(duì)象被認(rèn)為是const的。換句話說(shuō)，const修飾符修飾的是基礎(chǔ)類(lèi)型T而不是指針修飾符*。而對(duì)于cpt的聲明來(lái)說(shuō)，聲明的是一個(gè)指向一個(gè)非常量對(duì)象的常量指針，即const修飾符修飾的是指針修飾符*而不是基礎(chǔ)類(lèi)型T。

       聲明中的修飾符（即指針聲明中第一個(gè)*修飾符之前出現(xiàn)的任何東西）的順序無(wú)關(guān)性加劇了圍繞指針和常量的語(yǔ)法問(wèn)題。例如，以下兩行代碼所聲明的變量的類(lèi)型完全相同：

const T *p1; // 一個(gè)指向T類(lèi)型常量的指針
T const *p2; // 也是一個(gè)指向T類(lèi)型常量的指針

      第一種形式更傳統(tǒng)一些，但如今許多c++專家推薦使用第二種形式。理由在于，第二種形式不太容易被誤解，因?yàn)檫@種聲明可以倒過(guò)來(lái)讀，即“指向T類(lèi)型常量的指針”。使用哪一張形式無(wú)關(guān)緊要，只要保持一致就行了。然而，務(wù)必小心一個(gè)常見(jiàn)的錯(cuò)誤，那就是將常量指針的聲明與指向常量的指針的聲明混淆。

T const *p3; // 一個(gè)指向常量的指針
T *const p4 = pt;   // 一個(gè)常量指針,指向非常量T類(lèi)型

      當(dāng)然，可以聲明一個(gè)指向常量的常量指針：

const T *const cpct1 = pt; // 兩者均為常量
T const *const cpct2 = cpct1; // 同上

      注意，使用一個(gè)引用通常比使用一個(gè)常量指針更簡(jiǎn)單：

const T &rct = *pt; // 而不是const T *const
T &rt = *pt; // 而不是T *const

      注意我們能夠?qū)⒁粋€(gè)指向非常量的指針轉(zhuǎn)換成一個(gè)指向常量的指針。例如，我們能夠使用pt（類(lèi)型為T*）初始化pct（類(lèi)型為const T*）。從非技術(shù)的角度來(lái)說(shuō)，這樣做之所以合法，是因?yàn)椴粫?huì)產(chǎn)生任何不良后果。想想當(dāng)一個(gè)非常量對(duì)象的地址被復(fù)制到一個(gè)指向常量的指針時(shí)的情形，如圖1所示。

圖1 一個(gè)指向常量的指針可以指向一個(gè)非常量對(duì)象

      指向常量的指針pct現(xiàn)在指向一個(gè)非常量T，但這不會(huì)造成任何危害。實(shí)際上，指向常量的指針（或引用）去指向非常量的對(duì)象，是司空見(jiàn)慣的事情：

void aFunc(const T *arg1, const T &arg2);
// 
T *a = new T;
T b;
aFunc(a, b);

      調(diào)用aFunc時(shí)，使用a初始化arg1，使用b初始化arg2.我們并沒(méi)有宣傳a要指向一個(gè)常量對(duì)象，或者b是一個(gè)常量引用，只是聲明在aFunc函數(shù)中它們被視為常量，而不管它們實(shí)際上是否如此。這很有用。

相反的轉(zhuǎn)換，即從指向常量的指針轉(zhuǎn)換為指向非常量的指針，則是非法的，因?yàn)榭赡軙?huì)產(chǎn)生危險(xiǎn)的后果，如圖2所示。

圖2 指向非常量的指針不可以指向常量對(duì)象

      在這個(gè)例子中，pct可能實(shí)際上指向一個(gè)被定義為常量的對(duì)象。如果我們能夠?qū)⒁粋€(gè)指向常量的指針轉(zhuǎn)換為一個(gè)指向非常量的指針，那么pt就可以用于改變act的值。

const T act;
pct = &act;
pt = pct;;    // 報(bào)錯(cuò)！
*pt = at; // 試圖修改常量對(duì)象！

      C++標(biāo)準(zhǔn)告訴我們，這樣的賦值會(huì)產(chǎn)生未定義的結(jié)果，也就是說(shuō)，我們不知道究竟會(huì)發(fā)生什么，不過(guò)可以肯定的是，不會(huì)發(fā)生什么好事情。當(dāng)然，我們可以利用const_cast顯示的指向類(lèi)型轉(zhuǎn)換。

pt = const_cast<T *>(pct); // 沒(méi)有錯(cuò)，但這種做法不妥
*pt = at; // 試圖修改常量對(duì)象！

      然而，如果pt指向一個(gè)被聲明為常量的對(duì)象（例如act），那么以上賦值行為仍然是未定義的。

2. 指向指針的指針

       指向指針的指針，這就是C++標(biāo)準(zhǔn)所說(shuō)的“多級(jí)”指針。

int *pi; // 一級(jí)指針
int **ppi;    // 二級(jí)指針
int ***pppi;// 三級(jí)指針

     盡管超過(guò)兩級(jí)的多級(jí)指針很罕見(jiàn)，但在兩種情況下，確實(shí)會(huì)看到指向指針的指針。第一種情形是當(dāng)我們聲明一個(gè)指針數(shù)組時(shí)：

Shape *picture[MAX]; // 一個(gè)數(shù)組，其元素為指向Shape的指針

      由于數(shù)組的名字會(huì)退化為指向其首元素的指針，所以指針數(shù)組的名字也是一個(gè)指向指針的指針：

Shape **pic1 = picture;

      我們?cè)诠芾碇羔樉彌_區(qū)的類(lèi)的實(shí)現(xiàn)中最常看到這種用法：

template <typename T>
class PtrVector
{
public:
   explicit PtrVector(size_t capacity)
      : buf_(new T *[capacity]), cap_(capacity), size_(0)
   {

   }

   // 

private:
   T **buf_; // 一個(gè)指針，指向一個(gè)數(shù)組，該數(shù)組元素為指向T的指針
   size_t cap_; // 容量
   size_t size_; // 大小
};
// 
PtrVector<Shape> pic2(MAX);

      從PtrVector的實(shí)現(xiàn)可以看到，指向指針的指針可能會(huì)很復(fù)雜，最好將其隱藏起來(lái)。

多級(jí)指針的第二個(gè)常見(jiàn)應(yīng)用情形，是當(dāng)一個(gè)函數(shù)需要改變傳遞給它的指針的值時(shí)。考慮如下函數(shù)，它將一個(gè)指針移動(dòng)到指向字符串中的下一個(gè)字符：

void scanTo(const char **p, char c)
{
   while (**p && **p != c)
   {
      ++*p;
   }
}

      傳遞給scanTo的第一個(gè)參數(shù)是一個(gè)指向指針的指針，該指針值是我們希望改變的。這意味著我們必須傳遞指針的地址：

char s[] = "Hello World";
const char *cp = s;
scanTo(&cp, 'W');

      這種用法在C中時(shí)合理的，但在C++中，更習(xí)慣、更簡(jiǎn)單、更安全的做法是使用指向指針的引用作為函數(shù)參數(shù)，而不是指向指針的指針作為參數(shù)。

void scanTo(const char *&p, char c)
{
   while (*p && *p != c)
   {
      ++p;
   }
}
// 
char s[] = "Hello World";
const char *cp = s;
scanTo(cp, 'W');

      在C++中，幾乎總是首選使用指向指針的引用作為函數(shù)參數(shù)，而不是指向指針的指針。

一個(gè)常見(jiàn)的誤解是，適用于指針的轉(zhuǎn)換同樣適用于指向指針的指針。事實(shí)上并非如此。例如，我們知道一個(gè)指向派生類(lèi)的指針可被轉(zhuǎn)換為一個(gè)指向其公共基類(lèi)的指針：

Circle *c = new Circle;
Shape *s = c; // 正確

      因?yàn)?/span>Circle是一個(gè)（is-a）Shape，因而一個(gè)指向Circle的指針也是一個(gè)Shape指針。然而，一個(gè)指向Circle指針的指針并不是一個(gè)指向Shape指針的指針：

Circle **cc = &c;
Shape **s = cc; // 錯(cuò)誤！

      當(dāng)涉及const時(shí)也會(huì)發(fā)生同樣的混淆。我們知道，將一個(gè)指向非常量的指針轉(zhuǎn)換為一個(gè)指向常量的指針是合法的，但不可以將一個(gè)指向“指向非常量的指針”的指針轉(zhuǎn)換為一個(gè)指向“指向常量的指針”的指針：

char *s1 = 0;
const char *s2 = s1; // 正確
char *a[MAX]; // 即char **
const char **ps = a;    // 錯(cuò)誤！