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

2. 指向指針的指針

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

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

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

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

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

const T *p1; // 一個指向T類型常量的指針
T const *p2; // 也是一個指向T類型常量的指針

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

T const *p3; // 一個指向常量的指針
T *const p4 = pt;   // 一個常量指針,指向非常量T類型

      當然，可以聲明一個指向常量的常量指針：

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

      注意，使用一個引用通常比使用一個常量指針更簡單：

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

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

圖1 一個指向常量的指針可以指向一個非常量對象

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

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

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

相反的轉(zhuǎn)換，即從指向常量的指針轉(zhuǎn)換為指向非常量的指針，則是非法的，因為可能會產(chǎn)生危險的后果，如圖2所示。

圖2 指向非常量的指針不可以指向常量對象

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

const T act;
pct = &act;
pt = pct;;    // 報錯！
*pt = at; // 試圖修改常量對象！

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

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

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

2. 指向指針的指針

       指向指針的指針，這就是C++標準所說的“多級”指針。

int *pi; // 一級指針
int **ppi;    // 二級指針
int ***pppi;// 三級指針

     盡管超過兩級的多級指針很罕見，但在兩種情況下，確實會看到指向指針的指針。第一種情形是當我們聲明一個指針數(shù)組時：

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

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

Shape **pic1 = picture;

      我們在管理指針緩沖區(qū)的類的實現(xiàn)中最常看到這種用法：

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

   }

   // 

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

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

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

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

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

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

      這種用法在C中時合理的，但在C++中，更習(xí)慣、更簡單、更安全的做法是使用指向指針的引用作為函數(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ù)，而不是指向指針的指針。

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

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

      因為Circle是一個（is-a）Shape，因而一個指向Circle的指針也是一個Shape指針。然而，一個指向Circle指針的指針并不是一個指向Shape指針的指針：

Circle **cc = &c;
Shape **s = cc; // 錯誤！

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

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