在C++11中实现监听者模式

参考文章：https://coderwall.com/p/u4w9ra/implementing-signals-in-c-11

最近在完成C++大作业时，碰到了监听者模式的需求。

尽管C++下也可以通过声明IObserver这样的接口，做继承，然后实现类似Java中的监听者模式。

但是这种方法并不是最适合C++的。通过利用C++11中的函数对象和RAII，我们可以实现一个更符合C++国情的监听者模式。

代码如下：

	/* Signal class for implementing event. */
	template <typename... TFuncArgs>
	class Signal {
	public:
		using Callback = std::function<void(TFuncArgs...)>;

		/* Connection class.
		Disconnect() will be called automatically once it's out of scope.
		*/
		class SignalConnection {
		private:
			friend class Signal;
			/* We only allow class Signal to create a connection. */
			SignalConnection(Signal& signal, int id) noexcept:id(id), signal(signal) {}
		public:
			/* A copy constructor of "connection" is really confusing. just delete it. */
			SignalConnection(const SignalConnection& copy) = delete;
			/* without a copy constructor, we can't return SignalConnection, unless we provide a move constructor. */
			SignalConnection(SignalConnection&& toMove) noexcept : id(toMove.id), signal(toMove.signal),disconnected(toMove.disconnected) {}
			~SignalConnection() {
				Disconnect();
			}
			int id;
			Signal& signal;
			bool disconnected = false;
			void Disconnect() {
				if (disconnected)
					return;
				disconnected = true;
				signal.Disconnect(*this);
			}
		};

		/* <b>Register to the Signal.</b>
		Returns a connection object.
		the connection object will automatically disconnect once it's out of scope.*/
		SignalConnection Connect(Callback callback) {
			callbacks.push_back(std::pair<int, Callback>(idRoller++, callback));
			return SignalConnection(*this, idRoller - 1);
		}

		void Invoke(TFuncArgs... args) {
			for (auto& con : callbacks) {
				(con.second)(args...);
			}
		}

		void operator()(TFuncArgs... args) {
			Invoke(args...);
		}

	private:
		/* ID Counter.
		We look for the connection's corresponding callback using id, since the operator== of std::function doesn't work as imagine.
		*/
		int idRoller = 0;
		std::list<std::pair<int, Callback>> callbacks;

		void Disconnect(SignalConnection& t) {
			callbacks.erase(std::remove_if(callbacks.begin(), callbacks.end(), [&](auto& pCallback) {
				return pCallback.first == t.id;
			}), callbacks.end());
		}
	};

一共两个类，Signal类表示事件，SignalConnection是由Signal返回给监听者的一个句柄，用于取消监听。

SignalConnection在析构函数中会自动调用进行取消监听，这样监听者不用担心内存泄露的问题。

Signal中保存的回调是pair<int,Callback>的结构。因为std::function对象不能用==直接进行比较，因此我们需要对每个监听者分配一个独一无二的id，在取消监听时，通过比较这个id，来确定删除哪个监听者。

为了避免歧义，我们将SignalConnection类的复制构造函数设置为delete，但是允许move构造，不然Signal也无法在函数里返回一个SignalConnection了。

使用方法：

void TestFunc1(int t) {
	cout << "Func1" << endl;
}
void TestFunc2(int t,string someArg) {
	cout << "Func2" << endl;
}

int main(){
	using TestDelegate = Signal<int>;
	TestDelegate testEvent;
	TestDelegate::SignalConnection testCon1 = testEvent.Connect(&TestFunc1);
	TestDelegate::SignalConnection testCon2 = testEvent.Connect(std::bind(TestFunc2 ,std::placeholders::_1, "arg"));  //用bind去绑定参数
	auto testCon3 = testEvent.Connect(&TestFunc1);        //用auto简化声明
	testEvent(1);
...

可以看到使用起来非常简洁自然。

上面这个实现有一定的缺陷，就是当Signal被析构后，没办法通知SignalConnection去Disconnect。在这之后此时SignalConnection被析构的话，调用signal.Disconnect()会导致引用错误。

最先想到的改进方法是让SignalConnection在Disconnect之前检查Signal还在不在。

但是既然都已经析构了，我们是没有办法去检查的。除非我们让Signal在最开始构造的时候，必须在堆上构造，然后用shared_ptr保存。让SignalConnection保存一个weak_ptr去检查Signal是否被析构。实际情况下这种实现多少有点不美观。

第二种方法，就是尝试在Signal析构时，将连接到它的SignalConnection全部Disconnect。

这种方法，我们需要在Signal中保存SignalConnection的指针。在Connect时，我们不再返回SignalConnection的对象，而是SignalConnection的shared_ptr，同时保存一个对应的weak_ptr。这种方法相对来说要简洁一点，只是将Connect的返回类型改为了shared_ptr，其他特性都得到了保留。

	/* Signal class for implementing event. */
	template <typename... TFuncArgs>
	class Signal {
	public:
		using Callback = std::function<void(TFuncArgs...)>;

		/* Connection class.
		Disconnect() will be called automatically once it's out of scope.
		*/
		class SignalConnection {
		private:
			friend class Signal;
			/* We only allow class Signal to create a connection. */
			SignalConnection(Signal& signal) noexcept: signal(signal) {}
		public:
			/* A copy constructor of "connection" is really confusing. just delete it. */
			SignalConnection(const SignalConnection& copy) = delete;
			/* without a copy constructor, we can't return SignalConnection, unless we provide a move constructor. */
			SignalConnection(SignalConnection&& toMove) noexcept : id(toMove.id), signal(toMove.signal),disconnected(toMove.disconnected) {}
			~SignalConnection() {
				Disconnect();
			}
			Signal& signal;
			bool disconnected = false;
			void Disconnect() {
				if (disconnected)
					return;
				disconnected = true;
				signal.Disconnect(this);
			}
		};
		using SPConnection = std::shared_ptr<SignalConnection>;

		/* Register to the Signal.
		Returns a connection object.
		the connection object will automatically disconnect once it's out of scope.*/
		SPConnection Connect(Callback callback) {
			auto t = std::shared_ptr<SignalConnection>(new SignalConnection(*this));
			callbacks.push_back(std::pair<std::weak_ptr<SignalConnection>, Callback>(t, callback));
			return t;
		}

		void Invoke(TFuncArgs... args) {
			for (auto& con : callbacks) {
				(con.second)(args...);
			}
		}

		void operator()(TFuncArgs... args) {
			Invoke(args...);
		}

		~Signal() {
			for (auto& t : callbacks) {
				if (auto sp = t.first.lock()) {	//translate to shared_ptr
					sp->disconnected = true;
				}
			}
		}

	private:
		std::list<std::pair<std::weak_ptr<SignalConnection>, Callback>> callbacks;

		void Disconnect(SignalConnection* t) {
			callbacks.erase(std::remove_if(callbacks.begin(), callbacks.end(), [&](auto& pCallback) {
				auto ptr = pCallback.first.lock();
				return !ptr || ptr.get() == t;
			}), callbacks.end());
		}
	};

最后一个办法，我们不用修改任何函数签名就可以解决这个问题。

解决这个问题的关键是让SignalConnection得知Signal是否被析构。所以我们要在不受析构影响的堆内存中找一个地方存放这个信息，让Signal被析构的时候在这个地方表示自己已经被析构。然后在构造SignalConnection时，将这个内存地址一同传入SignalConnection。SignalConnection去检查这个内存就能知道Signal是否被析构了。为了防止内存泄露，最后一个检查的SignalConnection还需要把这块内存回收。

这其实就类似于引用计数了，而我们可以用智能指针去模拟这些行为，而不用自己真的去管理内存。代码如下。

	/* Signal class for implementing event. */
	template <typename... TFuncArgs>
	class Signal {
	public:
		using Callback = std::function<void(TFuncArgs...)>;
		std::shared_ptr<int> survivePtr;
		Signal() : survivePtr(make_shared<int>(0)) {
		}
		/* Connection class.
		Disconnect() will be called automatically once it's out of scope.
		*/
		class SignalConnection {
		private:
			friend class Signal;
			/* We only allow class Signal to create a connection. */
			SignalConnection(Signal& signal, int id, std::shared_ptr<int> survivePtr) noexcept:id(id), signal(signal), signalSurvivePtr(survivePtr){}
		public:
			/* A copy constructor of "connection" is really confusing. just delete it. */
			SignalConnection(const SignalConnection& copy) = delete;
			/* without a copy constructor, we can't return SignalConnection, unless we provide a move constructor. */
			SignalConnection(SignalConnection&& toMove) noexcept : id(toMove.id), signal(toMove.signal), disconnected(toMove.disconnected), signalSurvivePtr(toMove.signalSurvivePtr) {}
			~SignalConnection() {
				Disconnect();
			}
			int id;
			Signal& signal;
			bool disconnected = false;
			std::weak_ptr<int> signalSurvivePtr;
			void Disconnect() {
				if (disconnected || signalSurvivePtr.expired())
					return;
				disconnected = true;
				signal.Disconnect(*this);
			}
		};    

		/* <b>Register to the Signal.</b>
		Returns a connection object.
		the connection object will automatically disconnect once it's out of scope.*/
		SignalConnection Connect(Callback callback) {
			callbacks.push_back(std::pair<int, Callback>(idRoller++, callback));
			return SignalConnection(*this, idRoller - 1, survivePtr);
		}

		void Invoke(TFuncArgs... args) {
			for (auto& con : callbacks) {
				(con.second)(args...);
			}
		}

		void operator()(TFuncArgs... args) {
			Invoke(args...);
		}

	private:
		/* ID Counter.
		We look for the connection's corresponding callback using id, since the operator== of std::function doesn't work as imagine.
		*/
		int idRoller = 0;
		std::list<std::pair<int, Callback>> callbacks;

		void Disconnect(SignalConnection& t) {
			callbacks.erase(std::remove_if(callbacks.begin(), callbacks.end(), [&](auto& pCallback) {
				return pCallback.first == t.id;
			}), callbacks.end());
		}
	};

Signal中我们保存一个shared_ptr，在SignalConnection中保存的是weak_ptr。这样当Signal被析构时，该内存空间的引用计数归零，此时SignalConnection可以通过自己的weak_ptr得知Signal是否被析构。