“怎麼了 zero ？胃口不好麼？”，基本填飽肚子之後，Solmyr 覺得似乎應該關心一下他的學徒了。
“呃，沒什麼，只是 …… Solmyr ，C++ 爲什麼不支持垃圾收集呢？（注：垃圾收集是一種機制，保證動態分配了的內存塊會自動釋放，Java 等
語言支持這一機制。）”
Solmyr 嘆了口氣，用一種平靜的眼神盯着 zero ：“是不是在 BBS 上和人吵 C++ 和 Java 哪個更好？而且吵輸了？我早告訴過你，這種爭論再無聊不過了。”
“呃 …… 是”，zero 不得不承認 ——— Solmyr 的眼神雖然一點也不銳利，但是卻莫名其妙的讓 zero 產生了微微的恐懼感。
“而且，誰告訴你 C++ 不支持垃圾收集的？”
“啊！Solmyr 你不是開玩笑吧？！”
“zero 你得轉變一下觀念。我問你，C++ 支不支持可以動態改變大小的數組？”
“這 …… 好象也沒有吧？”
“那 vector 是什麼東西？”
“呃 ……”
“支持一種特性，並不是說非得把這個特性加到語法裏去，我們也可以選擇用現有的語言機制實現一個庫來支持這個特徵。以垃圾收集爲例，這裏我們的任務是要保證每一個被動態分配的內存塊都能夠被釋放，也就是說 ……”，Solmyr 不知從哪裏找出了一張紙、一支筆，寫到：
int* p = new int; // 1
delete p; // 2
“也就是說，對於每一個 1 ，我們要保證有一個 2 被調用，1 和 2 必須成對出現。我來問你，C++ 中有什麼東西是由語言本身保證一定成對出現的？”
“……”，zero 露出了努力搜索記憶的表情，不過很明顯一無所獲。
“提示一下，和類的創建有關。”
“哦！構造函數與析構函數！”
“正確。可惜普通指針沒有構造函數與析構函數，所以我們必須要寫一個類來加一層包裝，最簡單的就象這樣：”
class my_intptr
{
public:
int* m_p;
my_intptr(int* p){ m_p = p; }
~my_intptr(){ delete m_p; }
};
…………
my_intptr pi(new int);
*(pi.m_p) = 10;
…………
“這裏我們可以放心的使用 my_intptr ，不用擔心內存泄漏的問題：一旦 pi 這個變量被銷燬，我們知道 pi.p 指向的內存塊一定會被釋放。不過如果每次使用 my_intptr 都得去訪問它的成員未免太麻煩了。爲此，可以給這個類加上重載的 * 運算符：”
class my_intptr
{
private:
int* m_p;
public:
my_intptr(int* p){ m_p = p; }
~my_intptr(){ delete m_p; }
int& operator*(){ return *m_p; }
};
…………
my_intptr pi;
*pi = 10;
int a = *pi;
…………
“現在是不是看起來 my_intptr 就像是一個真正的指針了？正因爲如此，這種技術被稱爲智能指針。現在我問你，這個類還缺少哪些東西？”
zero 皺着眉頭，眼睛一眨一眨，看上去就像一臺慢速電腦正在辛苦的往它的硬盤上拷貝文件。良久，zero 擡起頭來，不太確定的說：“是不是還缺少一個拷貝構造函數和一個賦值運算符？”
“說說爲什麼。”，Solmyr 顯然不打算就這樣放過 zero。
“因爲 …… 我記得沒錯的話 …… 《50 誡 》（注：指《Effective C++ 2/e》一書）中提到過，如果你的類裏面有指針指向動態分配的內存，那麼一定要爲它寫一個拷貝構造函數和一個賦值運算符 …… 因爲 …… 否則的話，一旦你做了賦值，會導致兩個對象的指針指向同一塊內存。對了！如果是上面的類，這樣一來會導致同一個指針被 delete 兩次！”
“正確。那麼我們應該怎樣來實現呢？”
“這簡單，我們用 memcpy 把目標指針指向的內存中的內容拷貝過來。”
“如果我們的智能指針指向一個類的對象怎麼辦？注意，類的對象中可能有指針，不能用 memcpy。”
“那 …… 我們用拷貝構造的辦法。”
“如果我們的智能指針指向的對象不能拷貝構造怎麼辦？它可能有一個私有的拷貝構造函數。”
“那 ……”，zero 頓了一頓，決定老實承認，“我不知道。”
“問題在哪你知道麼？在於你沒有把智能指針看作指針。想象一下，如果我們對一個指針做賦值，它的含義是什麼？”
“呃，我明白了，在這種情況下，應該想辦法讓兩個智能指針指向同一個對象 …… 可是 Solmyr ，這樣以來豈不是仍然要對同一個對象刪除兩遍？”
“是的，我們得想辦法解決這 個問題，辦法不只一種。比較好的一種是爲每個指針維護一個引用計數值，每次賦值或者拷貝構造，就讓計數值加一，這意味着指向這個內存塊的智能指針又多了一 個；而每有一個智能指針被銷燬，就讓計數值減一，這意味着指向這個內存塊的智能指針少了一個；一旦計數值爲 0 ，就釋放內存塊。象這樣：”
class my_intptr
{
private:
int* m_p;
int* m_count;
public:
my_intptr(int* p)
{
m_p = p;
m_count = new int; // 初始化計數值爲 1
*m_count = 1;
}
my_intptr(const my_intptr& rhs) // 拷貝構造函數
{
m_p = rhs.m_p; // 指向同一塊內存
m_count = rhs.m_count; // 使用同一個計數值
(*m_count)++; // 計數值加 1
}
~my_intptr()
{
(*m_count)--; // 計數值減 1
if( *m_count == 0 ) // 已經沒有別的指針指向該內存塊了
{
delete m_p;
delete m_count;
}
}
my_intptr& operator=(const my_intptr& rhs)
{
if( m_p == rhs.m_p ) // 首先判斷是否本來就指向同一內存塊
return *this; // 是則直接返回
(*m_count)--; // 計數值減 1 ，因爲該指針不再指向原來內存塊了
if( *m_count == 0 ) // 已經沒有別的指針指向原來內存塊了
{
delete m_p;
delete m_count;
}
m_p = rhs.m_p; // 指向同一塊內存
m_count = rhs.m_count; // 使用同一個計數值
(*m_count)++; // 計數值加 1
}
…………
};
“其他部分沒有什麼太大變化，我不費事了。現在想象一下我們怎樣使用這種智能指針？”，Solmyr 放下了筆，再次拿起了筷子，有些惋惜的發現他愛吃的肉丸子已經冷了。
zero 想象着，有些遲疑。“我們 …… 可以用 new int 表達式作爲構造函數的參數來構造一個智能指針，然後 …… 然後我們可以任意的賦值，”，他開始抓住了思路，越說越快，“任意的用已經存在的智能指針來構造新的智能指針，智能指針的賦值運算符、拷貝構造函數和析構 會保證計數值始終等於指向該內存塊的智能指針數。”zero 似乎明白了他看到了怎樣的功能， 開始激動起來：“然後一旦計數值爲 0 被分配的內存塊就會釋放！也就是說 …… 有指針指向內存塊，它就不釋放，一旦沒有，它就自動釋放！太棒了！我們只要一開始正確的初始化智能指針，就可以象普通指針那樣使用它，而且完全不用擔心內 存釋放的問題！太棒了！”zero 激動的大叫：“這就是垃圾收集！Solmyr ！我們在飯桌上實現了一個垃圾收集器！”
Solmyr 很明顯沒有分享 zero 的激動：“我在吃飯，你能不能不要大叫‘飯桌上實現了一個垃圾收集器’這種倒胃口的話？”頓了一頓，Solmyr 帶着他招牌式的壞笑，以一種可惡的口吻說道：“而且請注意一下自己的形象。”
“嗯？”，zero 回過神來，發現自己不知什麼時候站了起來，而整個餐廳裏的人都在看着他嘿嘿偷笑，這讓他感覺自己像個傻瓜。
zero 紅着臉坐下，壓低了聲音問 Solmyr ：“不過 Solmyr ，這確實是一個的垃圾收集機制啊，只要我們把這個類改成 …… 嗯 …… 改成模板類，象這樣：”zero 抓過了紙筆，寫到：
template <typename T>
class my_ptr
{
private:
T* m_p;
int* m_count;
…………
};
“它不就能支持任意類型的指針了嗎？我們就可以把它用在任何地方。”
Solmyr 搖了搖頭：“不，你把問題想的太簡單了。對於簡單的類型，這個類確實可以處理的很好，但實際情況是很複雜的。考慮一個典型情況：類 Derived 是類 Base 的派生類，我們希望這樣賦值：”
Base* pb;
Derived pd;
…………
pb = pd;
“你倒說說看，這種情況，怎樣改用上面這個智能指針來處理？”
“……”，zero 沉默了。
“要實現一個完整的垃圾收集機制並不容易，因爲有許多細節要考慮。”，Solmyr 開始總結了，“不過，基本思路就是上面說的這些。值得慶幸的是，目前已經有了一個相當成熟的‘引用計數’智能指針，boost::shared_ptr。 大多數情況下，我們都可以使用它。另外，除了智能指針之外，還有一些技術也能夠幫助我們避開釋放內存的問題，比如內存池。但是，關鍵在於 ——— ”
Solmyr 再度用那種平靜的眼神盯着 zero ：
“身爲 C/C++ 程序員，必須有創造力。那種躺在語言機制上不思進取的人，那種必須要靠語法強制才知道怎樣編程的人，那種沒有別人告訴他該幹什麼就無所適從的人，不適合這門語言。
Solmyr 嘆了口氣，用一種平靜的眼神盯着 zero ：“是不是在 BBS 上和人吵 C++ 和 Java 哪個更好？而且吵輸了？我早告訴過你，這種爭論再無聊不過了。”
“呃 …… 是”，zero 不得不承認 ——— Solmyr 的眼神雖然一點也不銳利，但是卻莫名其妙的讓 zero 產生了微微的恐懼感。
“而且，誰告訴你 C++ 不支持垃圾收集的？”
“啊！Solmyr 你不是開玩笑吧？！”
“zero 你得轉變一下觀念。我問你，C++ 支不支持可以動態改變大小的數組？”
“這 …… 好象也沒有吧？”
“那 vector 是什麼東西？”
“呃 ……”
“支持一種特性，並不是說非得把這個特性加到語法裏去，我們也可以選擇用現有的語言機制實現一個庫來支持這個特徵。以垃圾收集爲例，這裏我們的任務是要保證每一個被動態分配的內存塊都能夠被釋放，也就是說 ……”，Solmyr 不知從哪裏找出了一張紙、一支筆，寫到：
int* p = new int; // 1
delete p; // 2
“也就是說，對於每一個 1 ，我們要保證有一個 2 被調用，1 和 2 必須成對出現。我來問你，C++ 中有什麼東西是由語言本身保證一定成對出現的？”
“……”，zero 露出了努力搜索記憶的表情，不過很明顯一無所獲。
“提示一下，和類的創建有關。”
“哦！構造函數與析構函數！”
“正確。可惜普通指針沒有構造函數與析構函數，所以我們必須要寫一個類來加一層包裝，最簡單的就象這樣：”
class my_intptr
{
public:
int* m_p;
my_intptr(int* p){ m_p = p; }
~my_intptr(){ delete m_p; }
};
…………
my_intptr pi(new int);
*(pi.m_p) = 10;
…………
“這裏我們可以放心的使用 my_intptr ，不用擔心內存泄漏的問題：一旦 pi 這個變量被銷燬，我們知道 pi.p 指向的內存塊一定會被釋放。不過如果每次使用 my_intptr 都得去訪問它的成員未免太麻煩了。爲此，可以給這個類加上重載的 * 運算符：”
class my_intptr
{
private:
int* m_p;
public:
my_intptr(int* p){ m_p = p; }
~my_intptr(){ delete m_p; }
int& operator*(){ return *m_p; }
};
…………
my_intptr pi;
*pi = 10;
int a = *pi;
…………
“現在是不是看起來 my_intptr 就像是一個真正的指針了？正因爲如此，這種技術被稱爲智能指針。現在我問你，這個類還缺少哪些東西？”
zero 皺着眉頭，眼睛一眨一眨，看上去就像一臺慢速電腦正在辛苦的往它的硬盤上拷貝文件。良久，zero 擡起頭來，不太確定的說：“是不是還缺少一個拷貝構造函數和一個賦值運算符？”
“說說爲什麼。”，Solmyr 顯然不打算就這樣放過 zero。
“因爲 …… 我記得沒錯的話 …… 《50 誡 》（注：指《Effective C++ 2/e》一書）中提到過，如果你的類裏面有指針指向動態分配的內存，那麼一定要爲它寫一個拷貝構造函數和一個賦值運算符 …… 因爲 …… 否則的話，一旦你做了賦值，會導致兩個對象的指針指向同一塊內存。對了！如果是上面的類，這樣一來會導致同一個指針被 delete 兩次！”
“正確。那麼我們應該怎樣來實現呢？”
“這簡單，我們用 memcpy 把目標指針指向的內存中的內容拷貝過來。”
“如果我們的智能指針指向一個類的對象怎麼辦？注意，類的對象中可能有指針，不能用 memcpy。”
“那 …… 我們用拷貝構造的辦法。”
“如果我們的智能指針指向的對象不能拷貝構造怎麼辦？它可能有一個私有的拷貝構造函數。”
“那 ……”，zero 頓了一頓，決定老實承認，“我不知道。”
“問題在哪你知道麼？在於你沒有把智能指針看作指針。想象一下，如果我們對一個指針做賦值，它的含義是什麼？”
“呃，我明白了，在這種情況下，應該想辦法讓兩個智能指針指向同一個對象 …… 可是 Solmyr ，這樣以來豈不是仍然要對同一個對象刪除兩遍？”
“是的，我們得想辦法解決這 個問題，辦法不只一種。比較好的一種是爲每個指針維護一個引用計數值，每次賦值或者拷貝構造，就讓計數值加一，這意味着指向這個內存塊的智能指針又多了一 個；而每有一個智能指針被銷燬，就讓計數值減一，這意味着指向這個內存塊的智能指針少了一個；一旦計數值爲 0 ，就釋放內存塊。象這樣：”
class my_intptr
{
private:
int* m_p;
int* m_count;
public:
my_intptr(int* p)
{
m_p = p;
m_count = new int; // 初始化計數值爲 1
*m_count = 1;
}
my_intptr(const my_intptr& rhs) // 拷貝構造函數
{
m_p = rhs.m_p; // 指向同一塊內存
m_count = rhs.m_count; // 使用同一個計數值
(*m_count)++; // 計數值加 1
}
~my_intptr()
{
(*m_count)--; // 計數值減 1
if( *m_count == 0 ) // 已經沒有別的指針指向該內存塊了
{
delete m_p;
delete m_count;
}
}
my_intptr& operator=(const my_intptr& rhs)
{
if( m_p == rhs.m_p ) // 首先判斷是否本來就指向同一內存塊
return *this; // 是則直接返回
(*m_count)--; // 計數值減 1 ，因爲該指針不再指向原來內存塊了
if( *m_count == 0 ) // 已經沒有別的指針指向原來內存塊了
{
delete m_p;
delete m_count;
}
m_p = rhs.m_p; // 指向同一塊內存
m_count = rhs.m_count; // 使用同一個計數值
(*m_count)++; // 計數值加 1
}
…………
};
“其他部分沒有什麼太大變化，我不費事了。現在想象一下我們怎樣使用這種智能指針？”，Solmyr 放下了筆，再次拿起了筷子，有些惋惜的發現他愛吃的肉丸子已經冷了。
zero 想象着，有些遲疑。“我們 …… 可以用 new int 表達式作爲構造函數的參數來構造一個智能指針，然後 …… 然後我們可以任意的賦值，”，他開始抓住了思路，越說越快，“任意的用已經存在的智能指針來構造新的智能指針，智能指針的賦值運算符、拷貝構造函數和析構 會保證計數值始終等於指向該內存塊的智能指針數。”zero 似乎明白了他看到了怎樣的功能， 開始激動起來：“然後一旦計數值爲 0 被分配的內存塊就會釋放！也就是說 …… 有指針指向內存塊，它就不釋放，一旦沒有，它就自動釋放！太棒了！我們只要一開始正確的初始化智能指針，就可以象普通指針那樣使用它，而且完全不用擔心內 存釋放的問題！太棒了！”zero 激動的大叫：“這就是垃圾收集！Solmyr ！我們在飯桌上實現了一個垃圾收集器！”
Solmyr 很明顯沒有分享 zero 的激動：“我在吃飯，你能不能不要大叫‘飯桌上實現了一個垃圾收集器’這種倒胃口的話？”頓了一頓，Solmyr 帶着他招牌式的壞笑，以一種可惡的口吻說道：“而且請注意一下自己的形象。”
“嗯？”，zero 回過神來，發現自己不知什麼時候站了起來，而整個餐廳裏的人都在看着他嘿嘿偷笑，這讓他感覺自己像個傻瓜。
zero 紅着臉坐下，壓低了聲音問 Solmyr ：“不過 Solmyr ，這確實是一個的垃圾收集機制啊，只要我們把這個類改成 …… 嗯 …… 改成模板類，象這樣：”zero 抓過了紙筆，寫到：
template <typename T>
class my_ptr
{
private:
T* m_p;
int* m_count;
…………
};
“它不就能支持任意類型的指針了嗎？我們就可以把它用在任何地方。”
Solmyr 搖了搖頭：“不，你把問題想的太簡單了。對於簡單的類型，這個類確實可以處理的很好，但實際情況是很複雜的。考慮一個典型情況：類 Derived 是類 Base 的派生類，我們希望這樣賦值：”
Base* pb;
Derived pd;
…………
pb = pd;
“你倒說說看，這種情況，怎樣改用上面這個智能指針來處理？”
“……”，zero 沉默了。
“要實現一個完整的垃圾收集機制並不容易，因爲有許多細節要考慮。”，Solmyr 開始總結了，“不過，基本思路就是上面說的這些。值得慶幸的是，目前已經有了一個相當成熟的‘引用計數’智能指針，boost::shared_ptr。 大多數情況下，我們都可以使用它。另外，除了智能指針之外，還有一些技術也能夠幫助我們避開釋放內存的問題，比如內存池。但是，關鍵在於 ——— ”
Solmyr 再度用那種平靜的眼神盯着 zero ：
“身爲 C/C++ 程序員，必須有創造力。那種躺在語言機制上不思進取的人，那種必須要靠語法強制才知道怎樣編程的人，那種沒有別人告訴他該幹什麼就無所適從的人，不適合這門語言。