C++11实现观察者模式

观察者模式

观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都得到通知并被自动更新，先看一个简单的观察者模式是如何实现的

class Subject;
class Observer
{
public:
  virtual ~Observer();
  virtual void Update(Subject* theChangedSubject)=0;
protected:
  Observer();
};
class Subject
{
public:
  virtual ~Subject();
  virtual void Attach(Observer*);
  virtual void Detach(Observer*);
  virtual void Notify();
protected:
  Subject();
private:
  List<Observer*> *_observers;
};
void Subject::Attach(Observer* o)
{
  _observers->Append(o);
}
void Subject::Detach(Observer* o)
{
  _observers->Remove(o);
}
void Subject::Notify()
{
  ListIterator<Observer*> i(_observers);
  for(i.First();!i.IsDone();i.Next())
  {
    i.CurrentItem()->Update(this);
  }
}

这种实现方式限制太多，最主要的两个限定是：第一，需要继承，继承是强对象关系，不够灵活，第二，观察者模式被通知的接口参数不支持变化，导致观察者不能应付接口的变化。

C++11改进观察者模式实现

class NonCopyable
{
protected:
  NonCopyable()=default;
  ~NonCopyable()=default;
  NonCopyable(const NonCopyable&)=delete;
  NonCopyable& operator = (const NonCopyable&)=delete;
};
#include<iostream>
#include<string>
#include<functional>
#include<map>
using namespace std;
template<typename Func>
class Events:NonCopyable
{
public:
  Events()
  {}
  ~Events(){}
  int Connect(Func&& f)
  {
    return Assgin(f);
  }
  int Connect(const Func& f)
  {
    return Assgin(f);
  }
  void Disconnect(int key)
  {
    m_connections.erase(key);
  }
  template<typename... Args>
  void Notify(Args&&... args)
  {
    for(auto& it:m_connections)
    {
      it.second(std::forward<Args>(args)...);
    }
  }
private:
  template<typename F>
  int Assgin(F&& f)
  {
    int k=m_observerId++;
    m_connections.emplace(k,std::forward<F>(f));
    return k;
  }
  int m_observerId=0;
  std::map<int,Func> m_connections;
};
struct stA
{
  int a,b;
  void print(int a,int b)
  {
    cout<<a<<", "<<b<<endl;
  }
};
void print(int a,int b)
{
  cout<<a<<", "<<b<<endl;
}
int main()
{
  Events<std::function<void(int,int)>> myevent;
  auto key=myevent.Connect(print);
  stA t;
  auto lambdakey=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(f);
  int a=1,b=2;
  myevent.Notify(a,b);
  myevent.Disconnect(key);
}

c++11实现的观察者模式，内部维护了一个泛型函数列表，观察者只需要将观察者函数注册进去即可，通知接口使用了可变参数模板，支持任意参数，消除了接口变化的影响