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

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

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

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

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

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

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

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

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

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

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

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

      在這個例子中，pct可能實際上指向一個被定義為常量的對象。如果我們能夠將一個指向常量的指針轉換為一個指向非常量的指針，那么pt就可以用于改變act的值。

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

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

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

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

2. 指向指針的指針

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

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

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

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

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

Shape **pic1 = picture;

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

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

   }

   // 

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

      從PtrVector的實現可以看到，指向指針的指針可能會很復雜，最好將其隱藏起來。

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

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

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

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

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

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

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

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

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

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

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

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

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