观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 ```cpp #include <iostream> #include <typeinfo> #include <map> #include <functional> class Noncopyable { protected: Noncopyable() = default; ~Noncopyable() = default; Noncopyable(const Noncopyable&) = delete; Noncopyable& operator=(const Noncopyable&) = delete; }; template <typename Func> class Events : Noncopyable { public: Events() {} ~Events() {} int Connect(Func&& f) { return Assign(f); } int connect(const Func& f) { return Assign(f); } void Disconnect(int key) { connections_.erase(key); } template <typename... Args> void Notify(Args&&... args) { for (auto& it : connections_) { it.second(std::forward<Args>(args)...); } } private: template <typename F> int Assign(F&& f) { int k = observerId_++; connections_.emplace(k, std::forward<F>(f)); return k; } private: int observerId_ = 0; std::map<int, Func> connections_; }; struct stA { int a; int b; void print(int a, int b) { std::cout << a << ", " << b << std::endl; } }; void print(int a, int b) { std::cout << a << ", " << b << std::endl; } int main(int argc, char** argv) { Events<std::function<void(int, int)>> myevent; auto key = myevent.Connect(print); stA t; auto lamdakey = myevent.Connect([&t](int a, int b) { t.a = a; t.b = b; }); std::function<void(int, int)> f = std::bind(&stA::print, &t, std::placeholders::_1, std::placeholders::_2); myevent.Connect(std::move(f)); int a = 1, b = 2; myevent.Notify(a, b); std::cout << t.a << ", " << t.b << std::endl; return 0; } ``` c++11实现的观察者模式，内部维护了一个泛型函数列表，观察者只需要将观察者函数注册进来即可，消除了继承导致的强耦合。通知接口使用了可变参数模板，支持任意参数，这就消除了接口变化的影响。