使用 C++11 编写类似 QT 的信号槽——下篇
要实现 Signal-Slot，Signal 类中应该拥有一个保存 std::function 的数组：
template<class FuncType> class Signal { public: std::vector<std::function<FuncType>> functionals; };
接下来将会按照下图中可能出现的问题设计 Signal-Slot：
1、当对象 A 被摧毁时，funcA 应该自动从 vector 中移除。
要实现自动管理操作，最好的方式是使用 C++ 的智能指针进行管理。智能指针作为一个单纯的变量，当智能指针为对象一个成员变量时，它的生命周期和对象一样，在对象被摧毁的同时智能指针也会自动销毁掉。因此需要一个 SlotImpl 类对 std::function 进行管理：
template<class FuncType> class SlotImpl { public: ~SlotImpl() { // 从 signal 对象的数组中移除 } Signal* signal; std::function<FuncType> function; };
当 SlotImpl 被摧毁时，会调用析构函数将 function 从数组中移除。那么什么时候摧毁 SlotImpl 呢？前面已经说过，SlotImpl 的生命周期由智能指针来管理。使用一个类 Slot，封装该智能指针：
template<class FuncType> class Slot { public: std::shared_ptr<SlotImpl<FuncType>> slot; };
然后将 Slot 作为类 A 的成员属性：
class A { public: void funcA() {} Slot<void(void)> slot; };
所以，当对象 A 被摧毁时，Slot 对象被摧毁，由于智能指针的关系，SlotImpl 对象也会被销毁，最后 SlotImpl 的析构函数中 funcA 从数组中移除。
其中有一个小问题，就是对象 signalA 也应该拥有 SlotImpl。SlotImpl 以什么形式保存在 signalA 中时，才能确保 SlotImpl 的生命周期是由 Slot 的智能指针 std::share_ptr 管理，而不是 signalA？
signalA 要维护对象 SlotImpl 的指针（从而进行回调操作），但绝不允许指染对象的生命周期。根据上面这句话，应该想到智能指针 std::weak_ptr（weak_ptr 是为了配合 shared_ptr 而引入的一种智能指针，它指向一个由 shared_ptr 管理的对象而不影响所指对象的生命周期，也就是将一个 weak_ptr 绑定到一个 shared_ptr 不会改变 shared_ptr 的引用计数。不论是否有 weak_ptr 指向，一旦最后一个指向对象的 shared_ptr 被销毁，对象就会被释放）。
Signal 类的设计更改为：
template<class FuncType> class Signal { public: std::vector<std::weak_ptr<SlotImpl<FuncType>>> slot; };
解决完第一个问题，还有第二个问题。
2、发生赋值操作 signalB = signalA 是，signalA 和 signalB 应该指向同一个数组。
为什么要指向同一个数组？因为当对象 A 被摧毁时，funcA 要从所有 Signal 对象中移除。显然赋值操作后，signalA 和 signalB 都拥有 funcA。如果 signalB 的数组只是 signalA 数组的拷贝，当 A 被摧毁后（因为保存类 signalA 的对象指针，很定会从 signalA 的数组中移除），signalB 发生回调操作时，会调用一个不存在的函数，最后报错。
解决的方法也是使用智能指针，和上面 Slot 的一样，使用类 SignalImpl：
template<class FuncType> class SignalImpl { public: std::weak_ptr<SlotImpl<FuncType>> slot; }; //------------------------------------------------------- template<class FuncType> class Signal { public: std::shared_ptr<SignalImpl<FuncType>> impl; };
使用 std::share_ptr，发生赋值操作后，signalA 和 signalB 都指向同一个 SignalImpl。
重点部分都已经介绍完，下面给出完整代码：
Signal.h
#pragma once #include <functional> #include <memory> #include <vector> namespace Simple2D { //--------------------------------------------------------------------- // bind_member //--------------------------------------------------------------------- template<class Return, class Type, class... Args> std::function<Return(Args...)> bind_member(Type* instance, Return(Type::*method)(Args...)) { /* 匿名函数 */ return[=] (Args&&... args) -> Return { /* 完美转发：能过将参数按原来的类型转发到另一个函数中 */ /* 通过完美转发将参数传递给被调用的函数 */ return (instance->*method)(std::forward<Args>(args)...); }; } //--------------------------------------------------------------------- // SignalImpl //--------------------------------------------------------------------- template<class SlotImplType> class SignalImpl { public: std::vector<std::weak_ptr<SlotImplType>> slots; }; //--------------------------------------------------------------------- // SlotImpl //--------------------------------------------------------------------- class SlotImpl { public: SlotImpl() {} virtual ~SlotImpl() {} /* 将该函数定义成已删除的函数，任何试图调用它的行为将产生编译期错误，是 C++11 标准的内容 */ SlotImpl(const SlotImpl&) = delete; /* 将该函数定义成已删除的函数，任何试图调用它的行为将产生编译期错误，是 C++11 标准的内容 */ SlotImpl& operator= (const SlotImpl&) = delete; }; //--------------------------------------------------------------------- // SlotImplT //--------------------------------------------------------------------- template<class FuncType> class SlotImplT : public SlotImpl { public: SlotImplT(const std::weak_ptr<SignalImpl<SlotImplT>>& signal, const std::function<FuncType>& callback) : signal(signal) , callback(callback) { } ~SlotImplT() { std::shared_ptr<SignalImpl<SlotImplT>> sig = signal.lock(); if ( sig == nullptr ) return; for ( auto it = sig->slots.begin(); it != sig->slots.end(); ++it ) { if ( it->expired() || it->lock().get() == this ) { it = sig->slots.erase(it); if ( it == sig->slots.end() ) { break; } } } } std::weak_ptr<SignalImpl<SlotImplT>> signal; std::function<FuncType> callback; }; //--------------------------------------------------------------------- // Slot //--------------------------------------------------------------------- class Slot { public: Slot() {} ~Slot() {} template<class T> explicit Slot(T impl) : impl(impl) {} operator bool() const { return static_cast< bool >(impl); } private: std::shared_ptr<SlotImpl> impl; }; //--------------------------------------------------------------------- // Signal //--------------------------------------------------------------------- template<class FuncType> class Signal { public: Signal() : impl(std::make_shared<SignalImpl<SlotImplT<FuncType>>>()) {} template<class... Args> void operator()(Args&&... args) { std::vector<std::weak_ptr<SlotImplT<FuncType>>> slotVector = impl->slots; for ( std::weak_ptr<SlotImplT<FuncType>>& weak_slot : slotVector ) { std::shared_ptr<SlotImplT<FuncType>> slot = weak_slot.lock(); if ( slot ) { slot->callback(std::forward<Args>(args)...); } } } Slot connect(const std::function<FuncType>& func) { std::shared_ptr<SlotImplT<FuncType>> slotImpl = std::make_shared<SlotImplT<FuncType>>(impl, func); /* 由于 SignalImpl 使用的是 std::weak_ptr，push_back 操作不会增加引用计数。 因此，如果调用函数 connect 后的返回值没有赋值给 Slot 对象，过了这个函数的 作用域 slotImpl 对象就会被释放掉 */ impl->slots.push_back(slotImpl); return Slot(slotImpl); } template<class InstanceType, class MemberFuncType> Slot connect(InstanceType instance, MemberFuncType func) { return connect(bind_member(instance, func)); } private: std::shared_ptr<SignalImpl<SlotImplT<FuncType>>> impl; }; }
在 Signal 类中对操作符 () 进行重载，使用了可变参模板，使用完美转发将参数传递到回调函数中。
下面有几点注意的问题：
1、SlotImplT 保存 SignalImpl 对象指针时使用了弱引用智能指针 std::weak_ptr，因为 SlotImplT 维护指针只是为了将 std::function 从 Signal 数组中移除，而不会指染 Signal 的生命周期。
2、要访问 std::weak_ptr 时，使用函数 lock 返回一个临时的 std::share_ptr。
总结：这个 Signal-Slot 是在 ClanLib 游戏引擎的源码中的，并非我原创。只是以如何编写 Signal-Slot 的思路对源码进行解析。虽然只有 100 多行代码，但其中包含了许多的 C++11 的特性。
