sigslot（c++信号槽库）源码分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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        

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
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;
			}
		}
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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();
		}
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
	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;
		}
	};

1
2
3
4
5
signal0 (const signal0< mt_policy > &s) 
template<class desttype >
void 	connect (desttype *pclass, void(desttype::*pmemfun)()) 
void 	emit () 
void 	operator() ()

1
2
3
typedef _signal_base0<mt_policy> base;
typedef typename base::connections_list connections_list;//std::list<_connection_base0<mt_policy> *>
using base::m_connected_slots;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
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;
	};

1
2
3
4
5
6
7
8
9
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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	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;
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
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;	
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
	}
}

1
2
3
4
virtual _connection_base0<mt_policy>* duplicate(has_slots_interface* pnewdest)
{
	return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
}