最近本來開始看libevent的源碼的，裏面看到一個叫Reactor模式，然後又感覺跟觀察者模式有點像，就去找他們的區別，偶然又發現了一個信號槽的庫sigslot。本來我是寫過一段時間的QT的，體會過QT信號槽的便捷，竟然有人用c++寫出這個庫，當然是要看一下的。關於信號槽機制讓一個信號與槽進行綁定，然後不管在任何位置發射信號，這個槽函數都會相應，所以方便性不言而喻。它的首頁地址是http://sigslot.sourceforge.net/。
首頁介紹寫的有點意思~
The Microsoft Foundation Classes (MFC) are a nightmarish mess. I'll say it again - the MFC is a programmer's nightmare. At one point it almost inspired me to give up programming and take up something less irritating, like becoming a professional 'nut the javelin' player or move to Outer Patagonia and become a cat wrangler. Nevertheless, the MFC is capable of supporting most things that you might want to do with the Windows platform, at the price of a little slice of one's sanity.
大致意思說MFC就是一個程序員的噩夢，它曾經差點讓作者放棄了編程，想去做養貓的，哈哈~
介紹
先整體介紹一下這個庫，通過構造signal0,signal1...signal8類的對象可以用於綁定槽與發射信號，通過繼承於has_slots<>類的對象，它的成員函數可以作爲槽函數來進行綁定。一個信號可以綁定多個槽，同樣一個槽也可以響應多個信號。通過拷貝構造可以複製它所有的信號槽，析構函數自動斷開連接，所以一般不需要手動斷開連接（除非必要）。裏面添加了多線程支持，WIN32下與Linux下，Linux下我不是很懂，所以主要分析WIN32下，通過一個宏定義可以控制使用的是單線程還是多線程，多線程分兩種，全局的與局部的，其實就是使用一個全局的臨界區還是每個信號與槽分別使用一個臨界區，一般全局的就可以，局部的效率應該會低很多。
從文檔中給出的實例開始分析：
class Switch
{
public:
signal0<> Clicked;//這裏的信號是不帶參數的，signaln表示帶幾個參數
};
class Light : public has_slots<>
{
public:
Light(bool state) { b_state = state; cout << "init: "; Displaystate(); }
void ToggleState() { b_state = !b_state; Displaystate(); } //作爲消息的響應
void TurnOn() { b_state = true; Displaystate(); }
void TurnOff() { b_state = false; Displaystate(); }
void Displaystate() { cout << "The state is " << b_state << endl; }
private:
bool b_state;
};
int main() {
Switch sw1, sw2, all_on, all_off;
Light lp1(true), lp2(false);
sw1.Clicked.connect(&lp1, &Light::ToggleState); //綁定
sw2.Clicked.connect(&lp2, &Light::ToggleState);
all_on.Clicked.connect(&lp1, &Light::TurnOn);
all_on.Clicked.connect(&lp2, &Light::TurnOn);
all_off.Clicked.connect(&lp1, &Light::TurnOff);
all_off.Clicked.connect(&lp2, &Light::TurnOff);
sw1.Clicked();//等價於sw1.Clicked.emit();
sw2.Clicked();
all_on.Clicked();
all_off.Clicked();
}
運行結果如下：
init: The state is 1
init: The state is 0
The state is 0
The state is 1
The state is 1
The state is 1
The state is 0
The state is 0
代碼中Switch對象與Light對象進行綁定，開關發射按開關的信號，燈進行響應，可以很好的很方便的模擬現實中的這個場景
Switch類中的成員Clicked用於發射信號，它是signal0<>類的一個對象，可以看出，signa0是一個模板類，看一下它的源碼：
template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
class signal0 : public _signal_base0<mt_policy>
{
public:
typedef _signal_base0<mt_policy> base;
typedef typename base::connections_list connections_list;//std::list<_connection_base0<mt_policy> *>
using base::m_connected_slots;//父類裏的成員list，保存了連接好的槽函數
signal0()
{
;
}
signal0(const signal0<mt_policy>& s)
: _signal_base0<mt_policy>(s)
{
;
}
template<class desttype>
void connect(desttype* pclass, void (desttype::*pmemfun)())
{
lock_block<mt_policy> lock(this);
_connection0<desttype, mt_policy>* conn =
new _connection0<desttype, mt_policy>(pclass, pmemfun);
//此處是將一個信號綁定到多個槽上
m_connected_slots.push_back(conn);
//此處就要求待綁定的類必須要繼承於has_slots,將this添加到sender中,但是註釋了下面這行依然可以正常工作？
pclass->signal_connect(this);
}
//發射信號時，將此信號連接的所有槽函數進行調用
void emit()
{
lock_block<mt_policy> lock(this);
typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
typename connections_list::const_iterator itEnd = m_connected_slots.end();
while (it != itEnd)
{
itNext = it;
++itNext;
(*it)->emit();
it = itNext;
}
}
//重載 () 運算符
void operator()()
{
lock_block<mt_policy> lock(this);
typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
typename connections_list::const_iterator itEnd = m_connected_slots.end();
while (it != itEnd)
{
itNext = it;
++itNext;
//此處的emit其實就是(m_pobject->*m_pmemfun) 讓綁定的成員調用它的成員函數
(*it)->emit();
it = itNext;
}
}
};
模板參數是控制使用什麼線程方式的，會發現源代碼裏很多lock_block<mt_policy> lock(this);這句代碼，lock_block是一個類，裏面有一個線程類的對象是mt_policy類型，
template<class mt_policy>
class lock_block
{
public:
mt_policy *m_mutex;
lock_block(mt_policy *mtx)
: m_mutex(mtx)
{
m_mutex->lock();
}
~lock_block()
{
m_mutex->unlock();
}
};
可以看到，構造函數進行鎖住，析構釋放鎖，就跟lock_guard一樣。mt_policy是等於宏SIGSLOT_DEFAULT_MT_POLICY，默認是#define SIGSLOT_DEFAULT_MT_POLICY single_threaded就是單線程類，單線程類則不保證在多線程環境下的線程安全問題。可以修改爲在創建信號槽對象時模板參數給定multi_threaded_global或multi_threaded_local,這兩個是線程類，比如看個global線程類的實現
class multi_threaded_global
{
public:
multi_threaded_global()
{
static bool isinitialised = false;
if (!isinitialised)
{
InitializeCriticalSection(get_critsec());
isinitialised = true;
}
}
multi_threaded_global(const multi_threaded_global&)
{
;
}
virtual ~multi_threaded_global()
{
;
}
virtual void lock()
{
EnterCriticalSection(get_critsec());
}
virtual void unlock()
{
LeaveCriticalSection(get_critsec());
}
private:
CRITICAL_SECTION* get_critsec()
{
static CRITICAL_SECTION g_critsec;
return &g_critsec;
}
};
構造函數保證臨界區對象只初始化一次，然後lock時進入臨界區，unlock時出臨界區。而信號槽類都繼承於線程類，所以可以保證對象的信號槽機制是線程安全的。而Local_thread則是定義爲成員變量，每次都獲取，釋放。整理一下線程這邊，構造信號槽對象時給定模板參數single_threaded或multi_threaded_global或multi_threaded_local，然後lock_block類使用這個線程類對象進行控制臨界區的訪問，每個信號槽都繼承於線程類，每項操作都要lock，所以保證了多線程下的線程安全，思路應該還是蠻清晰的。
回到signal0類中，有下面幾個成員函數
signal0 (const signal0< mt_policy > &s)
template<class desttype >
void connect (desttype *pclass, void(desttype::*pmemfun)())
void emit ()
void operator() ()
connect用於連接槽，emit與operator()從代碼中可以看出作用相同，是用來發射信號用的。
再看一下它的成員變量：
typedef _signal_base0<mt_policy> base;
typedef typename base::connections_list connections_list;//std::list<_connection_base0<mt_policy> *>
using base::m_connected_slots;
就只有父類的的一個m_connected_slots對象，父類定義爲：
typedef std::list<_connection_base0<mt_policy> *> connections_list;；
connections_list m_connected_slots;
好了，其實就是一個list，裏面保存的是_connection_base0<mt_policy>類型的指針。此時就要看一下signal0的父類_signal_base0的定義以及connection0的定義。刪除了disconnect部分的代碼，因爲它有點長，且並“沒有那麼重要”。
template<class dest_type, class mt_policy>
class _connection0 : public _connection_base0<mt_policy>
{
public:
_connection0()
{
m_pobject = NULL;
m_pmemfun = NULL;
}
_connection0(dest_type* pobject, void (dest_type::*pmemfun)())
{
m_pobject = pobject;
m_pmemfun = pmemfun;
}
virtual ~_connection0()
{
}
//clone是複製一個新的綁定好的槽與對象
virtual _connection_base0<mt_policy>* clone()
{
return new _connection0<dest_type, mt_policy>(*this);
}
//duplicate將一個新的對象與本類的成員函數綁定到一起
virtual _connection_base0<mt_policy>* duplicate(has_slots_interface* pnewdest)
{
return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
}
virtual void emit()
{
(m_pobject->*m_pmemfun)();
}
//獲取接收信號的槽函數的對象，即我發射信號，誰來響應
virtual has_slots_interface* getdest() const
{
return m_pobject;
}
private:
dest_type* m_pobject;
void (dest_type::* m_pmemfun)();//槽函數的函數指針
};
//=============================================
template<class mt_policy>
class _signal_base0 : public _signal_base<mt_policy>
{
public:
typedef std::list<_connection_base0<mt_policy> *> connections_list;
_signal_base0()
{
;
}
_signal_base0(const _signal_base0& s)
: _signal_base<mt_policy>(s)
{
lock_block<mt_policy> lock(this);
typename connections_list::const_iterator it = s.m_connected_slots.begin();
typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
while (it != itEnd)
{
(*it)->getdest()->signal_connect(this);
m_connected_slots.push_back((*it)->clone());
++it;
}
}
~_signal_base0()
{
disconnect_all();
}
bool is_empty()
{
lock_block<mt_policy> lock(this);
typename connections_list::const_iterator it = m_connected_slots.begin();
typename connections_list::const_iterator itEnd = m_connected_slots.end();
return it == itEnd;
}
void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
{
lock_block<mt_policy> lock(this);
typename connections_list::iterator it = m_connected_slots.begin();
typename connections_list::iterator itEnd = m_connected_slots.end();
while (it != itEnd)
{
//獲取oldtarget對象綁定的槽，複製給newtarget
if ((*it)->getdest() == oldtarget)
{
//此處的duplicate其實是將oldtarget對象綁定的槽跟newtarget綁定到一起
m_connected_slots.push_back((*it)->duplicate(newtarget));
}
++it;
}
}
protected:
connections_list m_connected_slots;
};
當信號對象調用connect時給定了對象與成員函數指針，然後內部構造了一個connection對象，然後添加到list中。再重複一下signal0中的connect函數的代碼：
void connect(desttype* pclass, void (desttype::*pmemfun)())
{
lock_block<mt_policy> lock(this);
_connection0<desttype, mt_policy>* conn = new _connection0<desttype, mt_policy>(pclass, pmemfun);
//此處是將一個信號綁定到多個槽上
m_connected_slots.push_back(conn);
//此處就要求待綁定的類必須要繼承於has_slots,將this添加到sender中，用於拷貝構造時的複製
pclass->signal_connect(this);
}
這部分應該不難理解，signal_connect(this);就是將當前信號添加到槽的senderSet集合中。所以信號的類結構如下
整理下信號類這邊。signal類對象調用connect()，參數爲一個繼承於has_slot<>類對象與它的成員函數，connect用一個connection來保存下這組對應關係，添加到signal的成員list中，signal通過emit或operator()發射信號，即遍歷這個connection_list，分別使用對象調用成員函數。通過拷貝構造可以將一個signal對象中保存的所有connection對象複製到新的signal對象中。析構函數自動釋放所有連接
接着到Slot類這邊，此類必須要繼承於has_slots類，不然在signal對象調用connect時最後一行pclass->signal_connect(this);會告訴你沒有signal_connect函數。看一下has_slots的類結構
看一下虛基類提供的接口
class has_slots_interface
{
public:
has_slots_interface()
{
;
}
virtual void signal_connect(_signal_base_interface* sender) = 0;
virtual void signal_disconnect(_signal_base_interface* sender) = 0;
virtual ~has_slots_interface()
{
}
virtual void disconnect_all() = 0;
};
就是一個連接，斷開連接。has_slots類僅僅是實現了虛函數，沒有增加新的接口。has_slots類中有一個成員，定義如下
typedef std::set<_signal_base_interface*> sender_set;
sender_set m_senders;
就是保存的是signal的基類指針，其實就是記錄了自己所關心的信號，雖然不添加看起來也能正常工作，但是當把這個槽的對象複製給另一個對象時，它便不能接收到信號了。可以看一下拷貝構造部分的代碼
has_slots(const has_slots& hs)
{
lock_block<mt_policy> lock(this);
const_iterator it = hs.m_senders.begin();
const_iterator itEnd = hs.m_senders.end();
while (it != itEnd)
{
(*it)->slot_duplicate(&hs, this);
m_senders.insert(*it);
++it;
}
}
裏面對每個sender，即signal對象調用了slot_duplicate函數，看一下slot_duplicate的實現方式
void slot_duplicate(const has_slots_interface* oldtarget, has_slots_interface* newtarget)
{
lock_block<mt_policy> lock(this);
typename connections_list::iterator it = m_connected_slots.begin();
typename connections_list::iterator itEnd = m_connected_slots.end();
while (it != itEnd)
{
//獲取oldtarget對象綁定的槽，複製給newtarget
if ((*it)->getdest() == oldtarget)
{
//此處的duplicate其實是將oldtarget對象綁定的槽跟newtarget綁定到一起
m_connected_slots.push_back((*it)->duplicate(newtarget));
}
++it;
}
}
再看到每個connection對象調用了duplicate函數,那再看一下它的代碼吧..
virtual _connection_base0<mt_policy>* duplicate(has_slots_interface* pnewdest)
{
return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
}
此處就是生成一個connection對象，與pnewdest綁定到一起。
整理一下：has_slots中的拷貝構造函數，對保存的每個sender(即signal對象)調用slot_duplicate，slot_duplicate遍歷connection_list，對每個connection對象調用duplicate，將槽函數綁定到新的槽對象中，然後將生成的新的connection對象添加到connection_list中，這樣的話每個sender發射信號時，這個新的槽對象也能響應這個信號，因爲它們已經被添加到connection_list中。
到此，不帶參數的部分就全部分析完了，我相信仔細看應該都能看明白。對於帶參數的，一共最多可以帶8個參數，此時在定義信號對象，槽對象時都需要帶上這些個參數，且類型，個數必須相同。所以源碼中就有了signal0,signal1...connction0,connection1...以及他們的基類。實現方式都差不多，無非就是加了個參數而已。
看完後覺得實現的還蠻巧妙，而且應該這種方法用其他語言應該都能實現。