指針

轉自：http://www.cppblog.com/aurain/archive/2011/03/28/142652.html 你這篇是轉載我的blog的，請註明出處。

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

2. 指向指針的指針

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

       往往有c++程序員說“常量指針”（const pointer）時，其想表達的意思往往是“指向常量的指針”（pointer to const），但實際上，這兩者是兩個完全不同的概念。
       將const修飾符放到指針聲明之前，應該想好，到底想讓什麼東西變成常量，是指針？還是準備指向的那個對象？或兼而有之？在pct的聲明中，指針不是const的，但它所指向的對象被認爲是const的。換句話說，const修飾符修飾的是基礎類型T而不是指針修飾符*。而對於cpt的聲明來說，聲明的是一個指向一個非常量對象的常量指針，即const修飾符修飾的是指針修飾符*而不是基礎類型T。

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

 

       聲明中的修飾符（即指針聲明中第一個*修飾符之前出現的任何東西）的順序無關性加劇了圍繞指針和常量的語法問題。例如，以下兩行代碼所聲明的變量的類型完全相同：      第一種形式更傳統一些，但如今許多c++專家推薦使用第二種形式。理由在於，第二種形式不太容易被誤解，因爲這種聲明可以倒過來讀，即“指向T類型常量的指針”。使用哪一張形式無關緊要，只要保持一致就行了。然而，務必小心一個常見的錯誤，那就是將常量指針的聲明與指向常量的指針的聲明混淆。
      當然，可以聲明一個指向常量的常量指針：

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

 

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

 

 

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

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

pt（類型爲T*）初始化pct（類型爲const T*）。從非技術的角度來說，這樣做之所以合法，是因爲不會產生任何不良後果。想想當一個非常量對象的地址被複制到一個指向常量的指針時的情形，如圖1所示。

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

      注意我們能夠將一個指向非常量的指針轉換成一個指向常量的指針。例如，我們能夠使用

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

      指向常量的指針pct現在指向一個非常量T，但這不會造成任何危害。實際上，指向常量的指針（或引用）去指向非常量的對象，是司空見慣的事情：
      調用aFunc時，使用a初始化arg1，使用b初始化arg2.我們並沒有宣傳a要指向一個常量對象，或者b是一個常量引用，只是聲明在aFunc函數中它們被視爲常量，而不管它們實際上是否如此。這很有用。

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

 

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

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

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

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

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

      C++

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

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

      然而，如果

2. 指向指針的指針

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

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

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

     

 

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

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

 

Shape **pic1 = picture;

      我們在管理指針緩衝區的類的實現中最常看到這種用法：

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

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);

      從

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

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

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

      傳遞給

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

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

      這種用法在

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

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

      在

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

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

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

      因爲

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

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

      當涉及

 

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