最近由於學cocos2d-x3.2，看到其中的回撥函式使用了std::bind，發現這是一個挺有趣的東西，它可以繫結一個函式，甚至一個函式物件，生成一個綁定了函式引數的函式物件，所以嘗試用它寫了一下觀察者模式。

首先是觀察者單例：

Ref是模仿cocos2d-x寫的一個包含最基礎引用計數的基類。

.h檔案

#include "Singleton.h"
#include "Ref.h"
#include "RefManage.h"
#include <functional>

/**
*	訊息管理(單例，嘗試實現類似cocos2d-x觀察者模式)
*/
class Notification :public Singleton<Notification>
{
public:
	//發出訊息
	void postMessage(const std::string& msg,Ref* data);
	//新增觀察者
	void addObserver(Ref* target,std::function<void(Ref*)> fun,const std::string& msg);
	//刪除觀察者
	bool removeObserver(Ref* ref,const std::string& msg);
	//訊息派發
	void dispatchMsg();

public:
	struct ObserverStr
	{
		Ref* _ref;				//觀察者物件
		std::function<void(Ref*)> _fun;		//繫結的類成員函式
		std::string _msg;			//監聽的訊息
	};
	struct MsgStr
	{
		std::string _msg;			//發出的訊息
		Ref* _data;				//附帶的資料
	};
private:
	Notification(void);
	~Notification(void);

	friend Singleton<Notification>;
	friend std::auto_ptr<Notification>;

private:
	std::vector<ObserverStr> m_observerVector;	//觀察者列表
	std::vector<MsgStr>	m_msgVector;		//訊息列表
};
 

.cpp

#include "Notification.h"

Notification::Notification(void)
{
	m_observerVector.clear();
}

Notification::~Notification(void)
{
	m_observerVector.clear();
}

void Notification::postMessage( const std::string& msg,Ref* data )
{
	MsgStr msgstr = {msg,data};
	m_msgVector.push_back(msgstr);
}

void Notification::addObserver( Ref* target,std::function<void(Ref*)> fun,const std::string& msg )
{
	ObserverStr obstr = {target,fun,msg};
	m_observerVector.push_back(obstr);
}

bool Notification::removeObserver( Ref* ref,const std::string& msg )
{

	for (auto it = m_observerVector.begin();it!=m_observerVector.end();++it)
	{
		if ((*it)._ref == ref && (*it)._msg.compare(msg)==0)
		{
			m_observerVector.erase(it);
			return true;
		}
	}
	return false;
}

void Notification::dispatchMsg()
{
	for (auto i = m_msgVector.begin();i!=m_msgVector.end();)
	{
		bool isErase = false;
		for (auto j = m_observerVector.begin();j!=m_observerVector.end();++j)
		{
			if ((*i)._msg.compare((*j)._msg) == 0)
			{
				((*j)._fun)((*i)._data);<span style="white-space:pre">	</span>//這是呼叫繫結的成員函式
				i = m_msgVector.erase(i);
				isErase = true;
			}
		}
		if(!isErase)
			++i;
	}
}
 

class ChildA : public Ref
{
public:
	ChildA(){}
	~ChildA(){};
	void postmsg(MyString* str){
		Notification::getInstance()->postMessage("child",str);}
};

class ChildB :public Ref
{
public:
	ChildB(){}
	void printdata(Ref* data)	{
		MyString* str = (MyString*)data;
		std::cout<<(str->m_str)<<std::endl;
	}
};

//用於傳遞的Data，也要繼承Ref
class MyString :public Ref
{
public:
	MyString(const std::string& str)
		{m_str = str;}

	std::string m_str;
};
 

主函式測試：

ChildA* p = new ChildA;
ChildB* q = new ChildB;

//新增觀察者
Notification::getInstance()->addObserver(q,std::bind(&ChildB::printdata,q,std::placeholders::_1),"child");
//傳送訊息
MyString* str = new MyString("data");
p->postmsg(str);

最後訊息迴圈中迴圈呼叫來派發訊息：

Notification::getInstance()->dispatchMsg();

從而通過bind的函式呼叫實現通知的效果。

測試結束時應該remove觀察者。

使用std::function和std::bind似乎可以實現許多耦合度較低的設計模式，這裡只是嘗試一下。

寫得不好，歡迎指正。