關(guān)于相等和不等
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
return a.get() != b.get();
}
由此可以看出，實(shí)際上它們就是簡單的比較內(nèi)部原始指針是否相等。因此可以得出這樣的判斷，對于使用==來比較的時候，以下情況下a和b會相等：
1.a、b都為空或者是都包含空指針，或者是其中之一。比如說如果a為空，b為空指針，那么也是相等的。
2.如果a和b存在著拷貝構(gòu)造或者是賦值關(guān)系，那么它們也是相等的。
同時我們也應(yīng)該注意到相等判斷只與內(nèi)部對象的地址有關(guān)系和內(nèi)部對象的值沒有關(guān)系，比如說:
shared_ptr<int> sp1 (new int (3));
shared_ptr<int> sp2 (new int (3));
由于sp1和sp2內(nèi)部的指針肯定不相同，因此sp1和sp2肯定不相等。
而不等于比較簡單，就是!(a==b)。
對于STL的關(guān)聯(lián)容器，它們對于是否存在的判斷標(biāo)準(zhǔn)是等價而不是相等。而等價的定義是如此：
template <class Ty1, class Ty2>
inline bool equiv(shared_ptr<Ty1> left,
shared_ptr<Ty2> right)
{
return !(left < right) && !(right < left);
}
對于shared_ptr來說，當(dāng)且僅當(dāng)如下情況時，這個函數(shù)才返回true，也就是等價關(guān)系成立：
1. left和right都為空。即：left和right都使用默認(rèn)構(gòu)造函數(shù)構(gòu)造。
2. left和right控制相同的受控源。即：left和right存在著某一方從另外一方拷貝構(gòu)造或者賦值的關(guān)系。
對于等價判斷實(shí)際上我們選擇的是shared_ptr的重載<，通過查看實(shí)現(xiàn)源碼可以發(fā)現(xiàn)最終發(fā)生比較關(guān)系的是shared_count的一個成員數(shù)據(jù)指針pi_：sp_counted_base * pi_;
friend inline bool operator<(shared_count const & a, shared_count const & b)
{
return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
}
因此，重載<只有當(dāng)pi_不相同的時候才有可能返回true。上面的語句通常情況下等于： return a.pi_ < b.pi_。通過參考上面的判別式!(left < right) && !(right < left)我們可以知道，除非a.pi_和b.pi_相同，否則判別式!(left < right) && !(right < left)永遠(yuǎn)不可能為true。
下面就可以把重點(diǎn)集中在什么時候會導(dǎo)致a.pi_與b.pi_相等了。
通過查看源碼我們可以發(fā)現(xiàn)當(dāng)且僅當(dāng)shared_count類對象使用默認(rèn)構(gòu)造的時候pi_才會被初始化為0，其它有參數(shù)的情況都會發(fā)生內(nèi)存分配，返回值保存在pi_當(dāng)中，先考察下面這幾個構(gòu)造函數(shù)：
shared_count()
template<class Y> explicit shared_count( Y * p )
template<class P, class D> shared_count( P p, D d )
template<class P, class D, class A> shared_count( P p, D d, A a )
template<class Y> explicit shared_count( std::auto_ptr<Y> & r )
這其中只有shared_count沒有對pi_進(jìn)行內(nèi)存分配，其它都分配了，而它們的參數(shù)均是直接由shared_ptr直接傳遞進(jìn)來的。而默認(rèn)構(gòu)造shared_ptr的時候，shared_count亦使用默認(rèn)構(gòu)造。下面是shared_ptr的數(shù)據(jù)成員：
T * px; // contained pointer
boost::detail::shared_count pn; // reference counter
下面的代碼證明了我所說的構(gòu)造方式：
shared_ptr(): px(0), pn() // never throws in 1.30+
{
}
template<class Y>
explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
{
boost::detail::sp_enable_shared_from_this( pn, p, p );
}
//
// Requirements: D's copy constructor must not throw
//
// shared_ptr will release p by calling d(p)
//
template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
{
boost::detail::sp_enable_shared_from_this( pn, p, p );
}
// As above, but with allocator. A's copy constructor shall not throw.
template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
{
boost::detail::sp_enable_shared_from_this( pn, p, p );
}
上面這些代碼證明了一點(diǎn)，在沒有發(fā)生拷貝構(gòu)造和賦值的前提下，只有當(dāng)使用默認(rèn)構(gòu)造的shared_ptr才等價，其它情況都不等價，哪怕T * px;的這個px相等，因?yàn)樗葍r比較沒有任何關(guān)系。同時通過源碼分析我們也可以發(fā)現(xiàn)一個奇怪的現(xiàn)象，即：
如果使用的是默認(rèn)構(gòu)造，那么即便是shared_ptr的類型不同，那么它們也會等價。而對于相等判斷來說，這會導(dǎo)致一個編譯錯誤。
當(dāng)然，你明白原理了就不奇怪了，因?yàn)槟闼容^的對象是類型無關(guān)的。下面的代碼將證明我所說的：
#include <iostream>
#include <boost/tr1/memory.hpp>
using namespace std;
using namespace std::tr1;
#define PrintExp( exp ) \
cout<< boolalpha << "( " << # exp << " ) = " << (exp) << endl
template <class Ty1, class Ty2>
inline bool equiv(shared_ptr<Ty1> left,
shared_ptr<Ty2> right)
{
return !(left < right) && !(right < left);
}
int main()
{
shared_ptr<int> sp1( new int(100) );
shared_ptr<int> sp2;
PrintExp( equiv( sp1, sp2 ) );
shared_ptr<double> sp3;
PrintExp( equiv( sp2, sp3 ) );
shared_ptr<int> sp4;
PrintExp( equiv( sp2, sp4 ) );
shared_ptr<int> sp5( (int*)NULL );
PrintExp( equiv( sp4, sp5 ) );
return 0;
}
等價還有另外一種情況，即通過拷貝構(gòu)造或者賦值，下面的代碼清楚的說明了為什么這些情況下，我們的pi_會相等最終導(dǎo)致判別式!(left < right) && !(right < left)為真：
shared_count(shared_count const & r): pi_(r.pi_) // nothrow
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
, id_(shared_count_id)
#endif
{
if( pi_ != 0 ) pi_->add_ref_copy();
}
// throws bad_weak_ptr when r.use_count() == 0
explicit shared_count(weak_count const & r);
// constructs an empty *this when r.use_count() == 0
shared_count( weak_count const & r, sp_nothrow_tag );
shared_count & operator= (shared_count const & r) // nothrow
{
sp_counted_base * tmp = r.pi_;
if( tmp != pi_ )
{
if( tmp != 0 ) tmp->add_ref_copy();
if( pi_ != 0 ) pi_->release();
pi_ = tmp;
} // 如果這里還有個else的話，那么就意味著pi_=tmp，因?yàn)?/span>tmp=r.pi_，則pi_=r.pi_。
// 那么pi_=tmp;這個賦值動作有
// 沒有又有什么關(guān)系呢？
return *this;
}
到這里我想我們對此應(yīng)該形成了一個比較清楚的概念了吧，呵呵。由于!(left < right) && !(right < left)的支持，使得shared_ptr可以作為容器的Key，比如說set、map等。另外補(bǔ)充一下就是weak_ptr也有類似的行為。
下面再附上一篇，這選自《Effective STL》的條款19，對我們理解這些很有幫助。
條款19：了解相等和等價的區(qū)別
STL充滿了比較對象是否有同樣的值。比如，當(dāng)你用find來定位區(qū)間中第一個有特定值的對象的位置，find必須可以比較兩個對象，看看一個的值是否與另一個相等。同樣，當(dāng)你嘗試向set中插入一個新元素時，set::insert必須可以判斷那個元素的值是否已經(jīng)在set中了。
find算法和set的insert成員函數(shù)是很多必須判斷兩個值是否相同的函數(shù)的代表。但它們以不同的方式完成，find對“相同”的定義是相等，基于operator==。set::insert對“相同”的定義是等價，通常基于operator<。因?yàn)橛卸x不同，所以有可能一個定義規(guī)定了兩個對象有相同的值而另一個定義判定它們沒有。結(jié)果，如果你想有效使用STL，那么你必須明白相等和等價的區(qū)別。
操作上來說，相等的概念是基于operator==的。如果表達(dá)式“x == y”返回true，x和y有相等的值，否則它們沒有。這很直截了當(dāng)，但要牢牢記住，因?yàn)?/span>x和y有相等的值并不意味著所有它們的成員有相等的值。比如，我們可能有一個內(nèi)部記錄了最后一次訪問的Widget類。
class Widget {
public:
...
private:
TimeStamp lastAccessed;
...
};
我們可以有一個用于Widget的忽略這個域的operator==：
bool operator==(const Widget& lhs, const Widget& rhs) {
// 忽略lastAccessed域的代碼
}
在這里，兩個Widget即使它們的lastAccessed域不同也可以有相等的值。
等價是基于在一個有序區(qū)間中對象值的相對位置。等價一般在每種標(biāo)準(zhǔn)關(guān)聯(lián)容器（比如，set、multiset、map和multimap）的一部分——排序順序方面有意義。兩個對象x和y如果在關(guān)聯(lián)容器c的排序順序中沒有哪個排在另一個之前，那么它們關(guān)于c使用的排序順序有等價的值。這聽起來很復(fù)雜，但實(shí)際上，它不。考慮一下，舉一個例子，一個set<Widget> s。兩個Widget w1和w2，如果在s的排序順序中沒有哪個在另一個之前，那么關(guān)于s它們有等價的值。set<Widget>的默認(rèn)比較函數(shù)是less<Widget>，而默認(rèn)的less<Widget>簡單地對Widget調(diào)用operator<，所以w1和w2關(guān)于operator<有等價的值如果下面表達(dá)式為真：
!(w1 < w2) // w1 < w2時它非真
&& // 而且
!(w2<w1) // w2 < w1時它非真
這個有意義：兩個值如果沒有哪個在另一個之前（關(guān)于某個排序標(biāo)準(zhǔn)），那么它們等價（按照那個標(biāo)準(zhǔn)）。
在一般情況下，用于關(guān)聯(lián)容器的比較函數(shù)不是operator<或甚至less，它是用戶定義的判斷式。（關(guān)于判斷式的更多信息參見條款39。）每個標(biāo)準(zhǔn)關(guān)聯(lián)容器通過它的key_comp成員函數(shù)來訪問排序判斷式，所以如果下式求值為真，兩個對象x和y關(guān)于一個關(guān)聯(lián)容器c的排序標(biāo)準(zhǔn)有等價的值：
!c.key_comp()(x, y) && !c.key_comp()(y, x) // 在c的排序順序中
// 如果x在y之前它非真，
// 同時在c的排序順序中
// 如果y在x之前它非真
表達(dá)式!c.key_comp()(x, y)看起來很丑陋，但一旦你知道c.key_comp()返回一個函數(shù)（或一個函數(shù)對象），丑陋就消散了。!c.key_comp()(x, y)只不過是調(diào)用key_comp返回的函數(shù)（或函數(shù)對象），并把x和y作為實(shí)參。然后對結(jié)果取反，c.key_comp()(x, y)僅當(dāng)在c的排序順序中x在y之前時返回真，所以!c.key_comp()(x, y)僅當(dāng)在c的排序順序中x不在y之前時為真。
要完全領(lǐng)會相等和等價的含義，考慮一個忽略大小寫的set<string>，也就是set的比較函數(shù)忽略字符串中字符大小寫的set<string>。這樣的比較函數(shù)會認(rèn)為“STL”和“stL”是等價的。條款35演示了怎么實(shí)現(xiàn)一個函數(shù)，ciStringCompare，它進(jìn)行了忽略大小寫比較，但set要一個比較函數(shù)的類型，不是真的函數(shù)。要天平這個鴻溝，我們寫一個operator()調(diào)用了ciStringCompare的仿函數(shù)類：
struct CIStringCompare: // 用于忽略大小寫
public // 字符串比較的類；
binary_function<string, string, bool> { // 關(guān)于這個基類的信息
// 參見條款40
bool operator()(const string& lhs,
const string& rhs) const
{
return ciStringCompare(lhs, rhs); // 關(guān)于ciStringCompare
} // 是怎么實(shí)現(xiàn)的參見條款35
}
給定CIStringCompare，要建立一個忽略大小寫的set<string>就很簡單了：
set<string, CIStringCompare> ciss; // ciss = “case-insensitive
// string set”
如果我們向這個set中插入“Persephone”和“persephone”，只有第一個字符串加入了，因?yàn)榈诙€等價于第一個：
ciss.insert("Persephone"); // 一個新元素添加到set中
ciss.insert("persephone"); // 沒有新元素添加到set中如果我們現(xiàn)在使用set的find成員函數(shù)搜索字符串“persephone”，搜索會成功，
if (ciss.find("persephone") != ciss.end())... // 這個測試會成功但如果我們用非成員的find算法，搜索會失敗：
if (find(ciss.begin(), ciss.end(),
"persephone") != ciss.end())... // 這個測試會失敗那是因?yàn)?#8220;persephone”等價于“Persephone”（關(guān)于比較仿函數(shù)CIStringCompare），但不等于它（因?yàn)?/span>string("persephone") != string("Persephone")）。這個例子演示了為什么你應(yīng)該跟隨條款44的建議優(yōu)先選擇成員函數(shù)（就像set::find）而不是非成員兄弟（就像find）的一個理由。
你可能會奇怪為什么標(biāo)準(zhǔn)關(guān)聯(lián)容器是基于等價而不是相等。畢竟，大多數(shù)程序員對相等有感覺而缺乏等價的感覺。（如果不是這樣，那就不需要本條款了。）答案乍看起來很簡單，但你看得越近，就會發(fā)現(xiàn)越多問題。
標(biāo)準(zhǔn)關(guān)聯(lián)容器保持有序，所以每個容器必須有一個定義了怎么保持東西有序的比較函數(shù)（默認(rèn)是less）。等價是根據(jù)這個比較函數(shù)定義的，所以標(biāo)準(zhǔn)關(guān)聯(lián)容器的用戶只需要為他們要使用的任意容器指定一個比較函數(shù)（決定排序順序的那個）。如果關(guān)聯(lián)容器使用相等來決定兩個對象是否有相同的值，那么每個關(guān)聯(lián)容器就需要，除了它用于排序的比較函數(shù)，還需要一個用于判斷兩個值是否相等的比較函數(shù)。（默認(rèn)的，這個比較函數(shù)大概應(yīng)該是equal_to，但有趣的是equal_to從沒有在STL中用做默認(rèn)比較函數(shù)。當(dāng)在STL中需要相等時，習(xí)慣是簡單地直接調(diào)用operator==。比如，這是非成員find算法所作的。）
讓我們假設(shè)我們有一個類似set的STL容器叫做set2CF，“set with two comparison functions”。第一個比較函數(shù)用來決定set的排序順序，第二個用來決定是否兩個對象有相同的值。現(xiàn)在考慮這個set2CF：
set2CF<string, CIStringCompare, equal_to<string> > s; 在這里，s內(nèi)部排序它的字符串時不考慮大小寫，等價標(biāo)準(zhǔn)直覺上是這樣：如果兩個字符串中一個等于另一個，那么它們有相同的值。讓我們向s中插入哈迪斯強(qiáng)娶的新娘（Persephone）的兩個拼寫：
s.insert("Persephone");
s.insert("persephone");
著該怎么辦？如果我們說"Persephone" != "persephone"然后兩個都插入s，它們應(yīng)該是什么順序？記住排序函數(shù)不能分別告訴它們。我們可以以任意順序插入，因此放棄以確定的順序遍歷set內(nèi)容的能力嗎？（不能已確定的順序遍歷關(guān)聯(lián)容器元素已經(jīng)折磨著multiset和multimap了，因?yàn)闃?biāo)準(zhǔn)沒有規(guī)定等價的值（對于multiset）或鍵（對于multimap）的相對順序。）或者我們堅持s的內(nèi)容的一個確定順序并忽略第二次插入的嘗試（“persephone”的那個）? 如果我們那么做，這里會發(fā)生什么？
if (s.find("persephone") != s.end())... // 這個測試成功或失敗？大概find使用了等價檢查，但如果我們?yōu)榱司S護(hù)s中元素的一個確定順序而忽略了第二個insert的調(diào)用，這個find會失敗，即使“persephone”的插入由于它是一個重復(fù)的值的原則而被忽略！
總之，通過只使用一個比較函數(shù)并使用等價作為兩個值“相等”的意義的仲裁者，標(biāo)準(zhǔn)關(guān)聯(lián)容器避開了很多會由允許兩個比較函數(shù)而引發(fā)的困難。一開始行為可能看起來有些奇怪（特別是當(dāng)你發(fā)現(xiàn)成員和非成員find可能返回不同結(jié)果），但最后，它避免了會由在標(biāo)準(zhǔn)關(guān)聯(lián)容器中混用相等和等價造成的混亂。
有趣的是，一旦你離開有序的關(guān)聯(lián)容器的領(lǐng)域，情況就變了，相等對等價的問題會——已經(jīng)——重臨了。有兩個基于散列表的非標(biāo)準(zhǔn)（但很常見）關(guān)聯(lián)容器的一般設(shè)計。一個設(shè)計是基于相等，而另一個是基于等價。我鼓勵你轉(zhuǎn)到條款25去學(xué)更多這樣的容器和設(shè)計以決定該用哪個。