智能指針的標準之爭：Boost vs. Loki
撰文/馬維達
2001 年10 月和2002 年4 月，在美國的華盛頓和荷蘭的安的列斯群島上分別召開了兩次C++標準會議。會議的內容之一是對一項新的C++特性提議——智能指針（Smart Pointer）——進行討論。本文將對可能成為C++新標準的兩種智能指針方案（Boost vs. Loki）進行介紹和分析，并給出了相應的使用實例。
關鍵詞：智能指針 C++ Boost Loki
在現在的標準C++中，只有一種智能指針：std::auto_ptr。其原因并非是因為auto_ptr 已足以應付所有相關的工作——實際上，auto_ptr 有一個重大的缺陷，就是它不能被用在STL 容器中——而是因為現在的C++標準在制定時并未能對智能指針進行全面的考察。按照C++標準委員會成員Herb Sutter 的說法，只有一種標準的智能指針是一件“可羞”的事情：首先，智能指針所能做的許多有用的事情，是可憐的auto_ptr 不能完成的；其次，在有些情況下使用auto_ptr 可能會造成問題，上面所說的不能在容器中使用就是一例。實際上，許多程序員已經開發了各種有用的智能指針，有些甚至在auto_ptr 被定為標準之前就已存在，但問題是，它們不是標準的。在這樣的情況下，C++標準委員會考慮引入新的智能指針，也就是自然而然的事情了。目前進入委員會視野的，主要有兩種智能指針方案：Boost 智能指針和Loki 智能指針。前者是由C++標準委員會庫工作組發起的Boost 組織開發的，而后者由世界級的C++專家Andrei Alexandrescu 開發，并在他所著的“Modern C++ Design”一書中進行了詳細的闡釋。下面，讓我們分別來看一看這兩種方案各自的技術特點。
一、 Boost 智能指針
Boost 的智能指針方案實現了五種智能指針模板類，每種智能指針都用于不同的目的。這五種智能指針是：
template<typename T> class scoped_ptr;
template<typename T> class scoped_array;
template<typename T> class shared_ptr;
template<typename T> class shared_array;
template<typename T> class weak_ptr;
下面將分別介紹它們各自的特性，并給出相應的使用實例：
scoped_ptr：意在用作指向自動（棧）對象的、不可復制的智能指針。該模板類存儲的是指向動態分配的對象（通過new 分配）的指針。被指向的對象保證會被刪除，或是在scoped_ptr 析構時，或是通過顯式地調用reset 方法。注意該模板沒有“共享所有權”或是“所有權轉讓”語義。同時，它也是不可復制的（noncopyable）。正因為如此，在用于不應被復制的指針時，它比shared_ptr 或std:auto_ptr 要更安全。與auto_ptr一樣，scoped_ptr 也不能用于STL 容器中；要滿足這樣的需求，應該使用shared_ptr。另外，它也不能用于存儲指向動態分配的數組的指針，這樣的情況應使用scoped_array。
下面是使用scoped_ptr 的一個簡單實例：
class CTest
{
public:
CTest() : m_id(0) {}
CTest(int id) : m_id(id) {}
~CTest() { std::cout << "id: " << m_id << " - Destructor is being called\n"; }
void SetId(int id) { m_id = id; }
int GetId() { return m_id; }
void DoSomething()
{ std::cout << "id: " << m_id << " - Doing something\n"; }
private:
int m_id;
};
void main()
{
boost::scoped_ptr<CTest> pTest(new CTest);
pTest->DoSomething();
}
其運行結果為：
id: 0 - Doing something
id: 0 - Destructor is being called
（以下的幾個例子所用的CTest 類的定義完全相同，為節省篇幅，不再列出——作者）
顯然，盡管我們自己沒有調用delete，pTest 仍然為我們正確地刪除了它所指向的對象。看起來scoped_ptr的用途和auto_ptr 十分類似，但實際上，scoped_ptr 類型的指針的所有權不可轉讓，這一點是和auto_ptr相當不同的。
scoped_array：該模板類與scoped_ptr 類似，但意在用于數組而不是單個對象。std::vector 可用于替換scoped_array，并且遠為靈活，但其效率要低一點。在不使用動態分配時，boost::array 也可用于替換scoped_array。
下面是一個使用scoped_array 的實例：
void main()
{
boost::scoped_array<CTest> pTest(new CTest[2]);
pTest[0].SetId(0);
pTest[1].SetId(1);
pTest[0].DoSomething();
pTest[1].DoSomething();
std::cout << '\n';
}
其運行結果為：
id: 0 - Doing something
id: 1 - Doing something
id: 1 - Destructor is being called
id: 0 - Destructor is being called
scoped_array 將負責使用delete []，而不是delete 來刪除它所指向的對象。
shared_ptr：意在用于對被指向對象的所有權進行共享。與scoped_ptr 一樣，被指向對象也保證會被刪除，但不同的是，這將發生在最后一個指向它的shared_ptr 被銷毀時，或是調用reset 方法時。shared_ptr符合C++標準庫的“可復制構造”（CopyConstructible）和“可賦值”（Assignable）要求，所以可被用于標
準的庫容器中。另外它還提供了比較操作符，所以可與標準庫的關聯容器一起工作。shared_ptr 不能用于存儲指向動態分配的數組的指針，這樣的情況應該使用shared_array。該模板的實現采用了引用計數技術，所以無法正確處理循環引用的情況。可以使用weak_ptr 來“打破循環”。shared_ptr 還可在多線程環境中使用。
下面的例子演示怎樣將shared_ptr 用于std::vector 中：
typedef boost::shared_ptr<CTest> TestPtr;
void PT(const TestPtr &t)
{
std::cout << "id: " << t->GetId() << "\t\t" << "use count: " << t.use_count() << '\n';
}
void main()
{
std::vector<TestPtr> TestVector;
TestPtr pTest0(new CTest(0));
TestVector.push_back(pTest0);
TestPtr pTest1(new CTest(1));
TestVector.push_back(pTest1);
TestPtr pTest2(new CTest(2));
TestVector.push_back(pTest2);
std::for_each(TestVector.begin(), TestVector.end(), PT);
std::cout << '\n';
pTest0.reset();
pTest1.reset();
pTest2.reset();
std::for_each(TestVector.begin(), TestVector.end(), PT);
std::cout << '\n';
TestVector.clear();
std::cout << '\n';
std::cout << "exiting...\n";
}
其運行結果為：
id: 0 use count: 2
id: 1 use count: 2
id: 2 use count: 2
id: 0 use count: 1
id: 1 use count: 1
id: 2 use count: 1
id: 0 - Destructor is being called
id: 1 - Destructor is being called
id: 2 - Destructor is being called
exiting...
運行結果中的“use count”是通過shared_ptr 的use_count()方法獲得的“使用計數”，也就是，對所存儲指針進行共享的shared_ptr 對象的數目。我們可以看到，在通過new 分配了3 個CTest 對象，并將相應的shared_ptr 對象放入TestVector 后，三個使用計數都為2；而在我們使用reset()方法復位pTest0、pTest1 和pTest2 后，TestVector 中的各個shared_ptr 對象的使用計數變成了1。這時，我們調用TestVector的clear()方法清除它所包含的shared_ptr 對象；因為已經沒有shared_ptr 對象再指向我們先前分配的3個CTest 對象，這3 個對象也隨之被刪除，并導致相應的析構器被調用。
shared_array：該模板類與shared_ptr 類似，但意在用于數組而不是單個對象。指向std::vector 的shared_ptr 可用于替換scoped_array，并且遠為靈活，但其效率也要低一點。
下面是使用實例：
void main()
{
boost::shared_array<CTest> pTest1(new CTest[2]);
pTest1[0].SetId(0);
pTest1[1].SetId(1);
std::cout << "use count: " << pTest1.use_count() << "\n\n";
boost::shared_array<CTest> pTest2(pTest1);
std::cout << "use count: " << pTest1.use_count() << "\n\n";
pTest1.reset();
pTest2[0].DoSomething();
pTest2[1].DoSomething();
std::cout << '\n';
std::cout << "use count: " << pTest1.use_count() << "\n\n";
}
其運行結果為：
use count: 1
use count: 2
id: 0 - Doing something
id: 1 - Doing something
use count: 1
id: 1 - Destructor is being called
id: 0 - Destructor is being called
如此例所示，我們通過new 所分配的數組只有在指向它的pTest1 和pTest2 都被銷毀或復位后才被刪除。
weak_ptr：該模板類存儲“已由shared_ptr 管理的對象”的“弱引用”。要訪問weak_ptr 所指向的對象，可以使用shared_ptr 構造器或make_shared 函數來將weak_ptr 轉換為shared_ptr。指向被管理對象的最后一個shared_ptr 被銷毀時將刪除該對象，即使仍有weak_ptr 指向它也是如此。與原始指針不同的是，屆時最后一個shared_ptr 會檢查是否有weak_ptr 指向該對象，如果有的話就將這些weak_ptr 置為空。這樣就不會發生使用原始指針時可能出現的“懸吊指針”（dangling pointer）情況，從而獲得更高的安全水平。
weak_ptr 符合C++標準庫的“可復制構造”（CopyConstructible）和“可賦值”（Assignable）要求，所以可被用于標準的庫容器中。另外它還提供了比較操作符，所以可與標準庫的關聯容器一起工作。
void main()
{
boost::shared_ptr<CTest> pTest(new CTest);
boost::weak_ptr<CTest> pTest2(pTest);
if(boost::shared_ptr<CTest> pTest3 = boost::make_shared(pTest2))
pTest3->DoSomething();
pTest.reset();
assert(pTest2.get() == NULL);
}
其運行結果為：
id: 0 - Doing something
id: 0 - Destructor is being called
main 函數最后的斷言確認了pTest2 所存儲的指針的確已被置為NULL。
顯然，Boost 的智能指針方案會讓我們產生這樣的疑問：如果我們還需要其他類型的智能指針（比如支持COM 的智能指針），是否意味著我們必須在C++中再增加智能指針類型，或是采用非標準的實現呢？在泛型技術已得到極大發展的今天，Boost 的“增加增加再增加”的思路是不能讓人滿意的。正是在這里，我們看到了下面將要介紹的Loki Smart Pointer 的關鍵點：通過基于策略（policy-based）的設計來實現通用的智能指針模板。
二、 Loki 智能指針
按照美國傳統辭典（雙解）的解釋，Loki 是“A Norse god who created discord, especially among his fellow gods.”（斯堪的納維亞的一個制造混亂的神，尤其是在其同類之間）。就其給Boost 智能指針帶來的麻煩而言，Loki 智能指針倒真的當得起這個名字；而在另一方面，就其實現的優雅以及功能的強大（也就是說，它給開發者帶來的好處）而言，它也的確屬于“神族”。
上面已經說過，Loki 的智能指針方案采用了基于策略的設計。其要點在于把將各功能域分解為獨立的、由主模板類進行混合和搭配的策略。讓我們先來看一看Loki 智能指針模板類SmartPtr 的定義：
template
<
typename T,
template <class>class OwnershipPolicy =RefCounted,
class ConversionPolicy =DisallowConversion,
template <class>class CheckingPolicy =AssertCheck,
template <class>class StoragePolicy =DefaultSPStorage
>
class SmartPtr;
我們可以看到，除了SmartPtr 所指向的對象類型T 以外，在模板類SmartPtr 中包括了這樣一些策略：OwnershipPolicy（所有權策略）、ConversionPolicy（類型轉換策略）、CheckingPolicy（檢查策略）、StoragePolicy（存儲策略）。正是通過這樣的分解，使得SmartPtr 具備了極大的靈活性。我們可以任意組合各種不同的策略，從而獲得不同的智能指針實現。下面先對各個策略逐一進行介紹：
OwnershipPolicy：指定所有權管理策略，可以從以下預定義的策略中選擇：DeepCopy（深度復制）、RefCounted（引用計數）、RefCountedMT（多線程化引用計數）、COMRefCounted（COM 引用計數）、RefLinked（引用鏈接）、DestructiveCopy（銷毀式復制），以及NoCopy（無復制）。
ConversionPolicy：指定是否允許進行向被指向類型的隱式轉換。可以使用的實現有AllowConversion 和DisallowConversion。
CheckingPolicy：定義錯誤檢查策略。可以使用AssertCheck、AssertCheckStrict、RejectNullStatic、RejectNull、RejectNullStrict，以及NoCheck。
StoragePolicy：定義怎樣存儲和訪問被指向對象。Loki 已定義的策略有：DefaultSPStorage、ArrayStorage、LockedStorage，以及HeapStorage。
除了Loki 已經定義的策略，你還可以自行定義策略。實際上，Loki 的智能指針模板覆蓋了四種基本的Boost 智能指針類型：scoped_ptr、scoped_array、shared_ptr 和shared_array；至于weak_ptr，也可以通過定義相應的策略來實現其等價物。通過即將成為C++標準（C++0x）的typedef 模板特性，我們還可以利用Loki 的SmartPtr 模板來直接定義前面提到的Boost 的前四種智能指針類型。舉例來說，我們可以這樣定義：
shared_ptr：
template<typename T> // typedef 模板還不是標準的
typedef Loki::SmartPtr
<
T,
RefCounted, // 以下都是缺省的模板參數
DisallowConversion,
AssertCheck,
DefaultSPStorage
>
shared_ptr;
下面是一個使用Loki “shared_ptr”的實例：
typedef Loki::SmartPtr<CTest> TestPtr;
void PT(const TestPtr &t)
{
std::cout << "id: " << t->GetId() << '\n';
}
void main()
{
std::vector<TestPtr> TestVector;
TestPtr pTest0(new CTest(0));
TestVector.push_back(pTest0);
TestPtr pTest1(new CTest(1));
TestVector.push_back(pTest1);
std::for_each(TestVector.begin(), TestVector.end(), PT);
std::cout << '\n';
Loki::Reset(pTest0, NULL);
Loki::Reset(pTest1, NULL);
std::for_each(TestVector.begin(), TestVector.end(), PT);
std::cout << '\n';
TestVector.clear();
std::cout << '\n';
std::cout << "exiting...\n";
}
其運行結果為：
id: 0
id: 1
id: 0
id: 1
id: 0 - Destructor is being called
id: 1 - Destructor is being called
exiting...
前面已經提到，要通過Loki 定義與Boost 的shared_ptr 功能等價的智能指針，除了第一個模板參數以外，其他的參數都可以使用缺省值，所以在上面的例子中，我們直接使用“typedef Loki::SmartPtr<CTest> TestPtr;”就可以了。非常的簡單！
為了進一步說明Loki 的“基于策略的設計方法”，讓我們再來看一個更為復雜的例子：通過Loki::SmartPtr 實現線程專有存儲（Thread-Specific Storage，TSS；又稱線程局部存儲，Thread Local Storage，TLS）。
所謂線程專有存儲，是指這樣一種機制，通過它，多線程程序可以使用一個邏輯上的全局訪問點來訪問線程專有的數據，并且不會給每次訪問增加額外的鎖定開銷。舉一個簡單的例子，在C 語言中，我們可以通過errno變量來獲取錯誤代碼；通常errno 就是一個普通的全局變量——在單線程環境中，這當然沒有什么問題，但如果
是多線程環境，這個全局的errno 變量就會給我們帶來麻煩了。TSS 正是解決這一問題的有效方案。
顯然，智能指針的語義能夠很好地適用于TSS。我們可以編寫一種智能指針，使得所有對其所指向對象的訪問都成為線程專有的——也就是說，每個線程訪問的實際上是自己專有的對象，但從程序的外表來看，卻都是對同一對象的訪問。有了Loki::SmartPtr，我們可以非常容易地實現這樣的智能指針：如其名字所指示的，TSS 涉及的是存儲問題，我們只要對Loki::SmartPtr 的StoragePolicy 進行定制就可以了，其他的工作可以交給Loki::SmartPtr 去完成。
在POSIX PThreads 庫和Win32 中都提供了用于線程專有存儲的函數，它們分別是pthread_key_create、pthread_setspecific、pthread_getspecific 和pthread_key_delete（POSIX PThreads 庫），以及TlsAlloc、TlsSetvalue、TlsGetvalue 和TlsFree（Win32）。關于這些函數的詳細信息，請參閱相關的文檔。
下面給出在MSVC 6.0 下實現的用于TSS 的StoragePolicy，并通過注釋逐行進行分析（這個實現使用了PThreads-Win32 庫，這是一個Win32 上的PThreads 實現。使用Win32 的線程專有函數也可以實現類似的StoragePolicy，但編寫在線程退出時調用的CleanupHook()卻需要一點“竅門”。具體方法可參考Boost 的thread_specific_ptr 實現）：
namespace Loki
{
// 實現TSS 的Loki 存儲策略。改編自Douglas C. Schmidt、Timothy H. Harrison
// 和Nat Pryce 的論文“Thread-Specific Storage for C/C++”中的部分代碼。
// 使用了“Loki VC 6.0 Port”。
template <class T> class TS_SPStorage
{
public:
typedef T* StoredType; // 被指向對象的類型。
typedef T* PointerType; // operator->所返回的類型。
typedef T& ReferenceType; // operator*所返回的類型。
public:
// 構造器。對成員變量進行初始化。
TS_SPStorage() : once_(0), key_(0), keylock_(NULL)
{ pthread_mutex_init(&keylock_, NULL); }
// 析構器。釋放先前獲取的資源。
~TS_SPStorage()
{
pthread_mutex_destroy(&keylock_);
pthread_key_delete(key_);
}
// 返回線程專有的被指向對象。
PointerType operator->() const { return GetPointee(); }
// 返回線程專有的被指向對象的引用。
ReferenceType operator*() { return *GetPointee(); }
// Accessors。獲取線程專有的被指向對象。
friend inline PointerType GetImpl(TS_SPStorage& sp)
{ return sp.GetPointee(); }
// 獲取線程專有的被指向對象的引用。
// 該函數沒有實現。但NoCheck 需要它才能正常工作。
friend inline const StoredType& GetImplRef(const TS_SPStorage& sp)
{ return 0; }
protected:
// 銷毀所存儲的數據。空函數。該工作將由CleanupHook()在各個線程退出時完成。
void Destroy() {}
// 獲取當前線程專有的數據。
PointerType GetPointee()
{
PointerType tss_data = NULL;
// 使用雙重檢查鎖定模式來在除了初始化以外的情況下避免鎖定。
// 之所以在這里，而不是在構造器中對“專有鑰”進行初始化及分配TS 對象，
// 是因為：(1) 最初創建TS 對象的線程（例如，主線程）常常并不是使用
// 它的線程（工作線程），所以在構造器中分配一個TS 對象的實例常常并無
// 好處，因為這個實例只能在主線程中訪問。(2)在有些平臺上，“專有
// 鑰”是有限的資源，所以等到對TS 對象進行第一次訪問時再進行分配，有
// 助于節省資源。
// 第一次檢查。
if(once_ == 0)
{
// 加鎖。確保訪問的序列化。
pthread_mutex_lock(&keylock_);
// 雙重檢查。
if(once_ == 0)
{
// 創建“專有鑰”。
pthread_key_create(&key_, &CleanupHook);
// 必須在創建過程的最后出現，這樣才能防止其他線程在“專有鑰”
// 被創建之前使用它。
once_ = 1;
}
// 解鎖。
pthread_mutex_unlock(&keylock_);
}
// 從系統的線程專有存儲中獲取數據。注意這里不需要加鎖。
tss_data = (PointerType)pthread_getspecific(key_);
// 檢查是否這是當前線程第一次進行訪問。
if (tss_data == NULL)
{
// 從堆中為TS 對象分配內存。
tss_data = new T;
// 將其指針存儲在系統的線程專有存儲中。
pthread_setspecific(key_, (void *)tss_data);
}
return tss_data;
}
private:
// 用于線程專有數據的“專有鑰”。
pthread_key_t key_;
// “第一次進入”標志。
int once_;
// 用于避免在初始化過程中產生競態情況。
pthread_mutex_t keylock_;
// 清掃掛鉤函數，釋放為TS 對象分配的內存。在每個線程退出時被調用。
static void CleanupHook (void *ptr)
{
// 這里必須進行類型轉換，相應的析構器才會被調用（如果有的話）
delete (PointerType)ptr;
}
};
// 用于模擬typedef template 的結構。
// 參見Herb Sutter 的“Template Typedef”一文。
struct TS_SPStorageWrapper
{
template <class T>
struct In
{
typedef TS_SPStorage<T> type;
};
};
};
下面讓我們來看一個使用實例。首先讓我們先定義：
Loki::SmartPtr
<
int,
Loki::NoCopyWrapper,
Loki::DisallowConversion,
Loki::NoCheckWrapper,
Loki::TS_SPStorageWrapper
> value;
其含義為：定義一種智能指針，被它指向的類型是int，OwnershipPolicy 是NoCopy，ConversionPolicy是DisallowConversion，CheckingPolicy 是NoCheck（因為TS 對象存儲方式的限制，這是惟一能和TS_SPStorage 一起使用的CheckingPolicy。讀者可自行嘗試找到更好的解決方案），StoragePolicy 是TS_SPStorage。
然后，編寫這樣一個程序：
pthread_mutex_t io_mutex = NULL; // iostreams 不一定是線程安全的!
void *thread_proc(void *param)
{
int id = (int)param;
*value = 0;
for (int i = 0; i < 3; i++)
{
(*value)++;
pthread_mutex_lock(&io_mutex);
std::cout << "thread " << id << ": " << *value << '\n';
pthread_mutex_unlock(&io_mutex);
}
return NULL;
}
void main(int argc, char* argv[])
{
pthread_mutex_init(&io_mutex, NULL);
pthread_t id[3];
for(int i = 0; i < 3; i++)
pthread_create(&id[i], 0, thread_proc, (void *)i);
for(int i = 0; i < 3; i++)
pthread_join(id[i], NULL);
pthread_mutex_destroy(&io_mutex);
}
其運行結果為：
thread 0: 1
thread 0: 2
thread 1: 1
thread 2: 1
thread 1: 2
thread 2: 2
thread 1: 3
thread 2: 3
thread 0: 3
由此我們可以看出，盡管看起來在各個線程中訪問的都是同樣的*value，但實際上訪問的卻是各自的線程專有的對象。而且除了初始化以外，對這些對象的訪問無需進行序列化。因為Loki::SmartPtr 為我們做了大量的工作，TS_SPStorage 的實現十分簡潔明了。有興趣的讀者，可以對這里的實現與Boost 的thread_specific_ptr 進行比較。像這樣對Loki::SmartPtr 的策略進行的定制，在理論上數目是無限的，也就是說，通過它我們可以擁有五花八門、“千奇百怪”的智能指針——了不起的Loki，不是嗎？有了這樣的模板類，我們就再不需要一次一次地為標準C++增加新的智能指針類型了。
三、 結束語
在推進器Boost 和斯堪的納維亞之神Loki 的戰爭中，誰將勝出恐怕已不言而喻。倘若扮演上帝的C++標準委員會起了偏心，硬要選中Boost 的智能指針方案的話，那么在接下來的日子里，他們就將不再是C++標準委員會，而是C++智能指針救火委員會了。而即便那樣，Loki，斯堪的納維亞之神，也仍將矗立在C++大陸上，為他的“子民”——C++程序員們——帶來統一、秩序和和諧。
相關資源
1. Herb Sutter，The New C++: Smart(er) Pointers，見C++ User Journal 網站：http://www.cuj.com/experts/2008/sutter.htm
2. Boost 文檔：http://www.boost.org
3. Andrei Alexandrescu，Modern C++ Design 及Loki，見http://www.moderncppdesign.com或http://www.awprofessional.com/catalog/product.asp?product_id=%7B4ED3E6F3-371F-4ADC-9810-CC7B936164E3%7D。
4. Douglas C. Schmidt、Timothy H. Harrison 和Nat Pryce，Thread-Specific Storage for C/C++，見http://www.cs.wustl.edu/~schmidt/或http://www.flyingdonkey.com/ace/（中文）。
5. Herb Sutter，Template Typedef，見http://www.gotw.ca/gotw/079.htm。
6. PThreads-Win32 庫，見http://sources.redhat.com/pthreads-win32/。