实现无需OO机制的观察者（性能至上）

模式大部分实现利用的是编程语言的继承多态等机制，以面向接口编程优先使用组合等等原则为实作的依归，把系统高内聚低耦合地划分了许多相对独立的类来实现拼装，模式套用多了难免出现很多类及各种子类，但却很大程度从结构上让系统的可维护性增强了，一般来说现在很多公司的OO系统就是这样做出来的。

看到一些古老一点的技术书籍，硬件还不像现在这样犀利的时候，其实OO语言常会因为性能问题被程序员诟病，不OO吧，系统真难维护，OO了，性能跑不赢，真是很博弈。偏执狂好像什么时代都会有，当时个别骨灰级程序员就为了性能和维护性兼而有之，无限挖掘语言的潜能，利用模板实现可维护性高的模式，同时由于模板的使用减少了对继承虚类等机制的依赖，性能又得到很大程度的提升，于是这种C++设计的新思维也算热闹了一阵。

正如observer之于delegate，observer的实现直观地使用了语言多态机制，已经很大程度地解耦了，譬如MVC中某model update了，各个view需要相应变化，observer pattern的limitation在于各concrete observer继承自同一个protocol class，you know what? 这就要求concrete observer实现了相同名字的update方法，并且同一个父亲，有完美主义的人对此一点点的小关联小耦合还是觉得不爽，所以又看到了observer pattern的另一种实现方式，即delegate。他们要observer之间更独立，不用同一个父亲，update方法无需同名，真是又自由又有性能。observer pattern的继承实现很简单直观，按下不表了，这里浅显地窥探一下delegate的实现。两种实现的工具对比，第一种实现利用语言的OO机制，第二种利用了类模板特化偏特化。

以下只是简略实现，抽出主要脉络，方便理解，如若想知道稳定可靠的实现，请参看boost源码。

template <typename R , class T1>
class Delegate<R (T1)>
{

template <typename T>
void add(const T& f)
{}

template <typename T>
Delegate& operator +=(const T& f)
{}

R operator () (T1 a1)
{}

std::vector<ICallBack*>* callbacks_;

// ......
}

class observerable
{

Delegate<int (char* str)> observers;

void update(char* event)
{
    observers(event);
}

}

class observer1
{

int action(char* str)
{}

}

class observer2
{

int update(char* str)
{}

}

int main()
{

observerable subject;
observer1 ob1;
observer2 ob2;

subject.observers += std::make_pair(&ob1, &observer1::action);
subject.observers += std::make_pair(&ob2, &observer2::update);

//triger update on subject ...
subject.update("Take action");

//then ob1.action(char*) and ob2.update(char*) should be invoked

}