程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> 【C/C++學院】0901

【C/C++學院】0901

編輯：關於C++

備忘錄模式

數據庫的備份，文檔編輯中的撤銷等功能

#include 
#include 
#include 
using namespace std;

//備忘錄模式：備忘錄對象是一個用來存儲另外一個對象內部狀態的快照的對象。
//備忘錄模式的用意是在不破壞封裝的條件下，將一個對象的狀態捉住，
//並外部化，存儲起來，從而可以在將來合適的時候把這個對象還原到存儲起來的狀態。
//同時跟幾個MM聊天時，一定要記清楚剛才跟MM說了些什麼話
//，不然MM發現了會不高興的哦，幸虧我有個備忘錄，
//剛才與哪個MM說了什麼話我都拷貝一份放到備忘錄裡面保存，
//這樣可以隨時察看以前的記錄啦
//設計需要回放的軟件，記錄一下事物的狀態。數據庫備份，文檔的編譯，撤銷，恢復
//設計備忘錄三大步驟
//1.設計記錄的節點，存儲記錄，//記錄鼠標，鍵盤的狀態
//2.設計記錄的存儲，vector,list，map,set,鏈表，圖，數組，樹
//3.操作記錄的類，記錄節點狀態，設置節點狀態，顯示狀態，0.1秒記錄一下

//備忘錄的節點，
class Memo
{
public:
	string state;
	Memo(string state) //記錄當前的狀態，
	{
		this->state = state;
	}
};

class Originator//類的包含備忘錄的節點
{
public:
	string state;
	void setMemo(Memo *memo)
	{
		state = memo->state;
	}
	Memo *createMemo()
	{
		return new Memo(state);
	}
	void show()
	{
		cout << state << endl;
	}
};


//備忘錄的集合
class Caretaker
{
public:
	vector memo;
	void save(Memo *memo)
	{
		(this->memo).push_back(memo);
	}
	Memo *getState(int i)
	{
		return memo[i];
	}
};

int main1()
{
	Originator *og = new Originator();
	Caretaker *ct = new Caretaker();

	og->state = "on";
	og->show();
	ct->save(og->createMemo());

	og->state = "off";
	og->show();
	ct->save(og->createMemo());

	og->state = "middle";
	og->show();
	ct->save(og->createMemo());

	og->setMemo(ct->getState(1));
	og->show();

	og->setMemo(ct->getState(2));
	og->show();
	cin.get();
	return 0;
}

策略模式

依賴於多態。

360服務端更新殺毒腳本進行客戶端殺毒的操作。邏輯腳本存儲在服務器，接口在客戶端進行實現。

#include 
#include 
#include 
using namespace std;

//策略模式：策略模式針對一組算法，將每一個算法封裝到具有共同接口的獨立的類中，
//從而使得它們可以相互替換。策略模式使得算法可以在不影響到客戶端的情況下
//發生變化。策略模把行為和環境分開。環境類負責維持和查詢行為類，
//各種算法在具體的策略類中提供。由於算法和環境獨立開來，算法的增減，
//修改都不會影響到環境和客戶端。

//跟不同類型的MM約會，要用不同的策略，有的請電影比較好，
//有的則去吃小吃效果不錯，有的去海邊浪漫最合適，單目的都是為了得到MM的芳心，
//我的追MM錦囊中有好多Strategy哦。
//策略的抽象類，接口，抽象類的指針可以訪問所有子類對象，（純虛函數）
//實現的各種策略，各種策略的實現類，都必須繼承抽象類
//策略的設置接口類，設置不同策略

class CashSuper
{
public:
	virtual double acceptMoney(double money) = 0;//抽象類，收錢的純虛函數
};

class CashNormal :public CashSuper
{
public:
	double acceptMoney(double money)//正常收錢
	{
		return money;
	}
};

class CashRebate :public CashSuper //打折
{
private:
	double discount;
public:
	CashRebate(double dis) //折扣
	{
		discount = dis;
	}
	double acceptMoney(double money)//收錢
	{
		return money*discount;//折扣
	}
};

class CashReturn :public CashSuper
{
private:
	double moneyCondition;
	double moneyReturn;
public:
	CashReturn(double mc, double mr)//花多少錢，返回多少錢
	{
		moneyCondition = mc;
		moneyReturn = mr;
	}
	double acceptMoney(double money)//收錢，返款
	{
		double result = money;
		if (money >= moneyCondition)
		{
			result = money - floor(money / moneyCondition)*moneyReturn;
		}
		return result;
	}
};

class  CashContext
{
private:
	CashSuper *cs;
public:
	CashContext(string str)//設置策略
	{
		if (str == "正常收費")
		{
			cs = new CashNormal();
		}
		else if (str == "打9折")
		{
			cs = new CashRebate(0.9);
		}
		else if (str == "滿1000送200")
		{
			cs = new CashReturn(1000, 200);
		}
	}
	double getResult(double money)
	{
		return cs->acceptMoney(money);
	}
};

int main123 ()
{
	double money = 1000;
	CashContext *cc = new CashContext("正常收費");
	cout << cc->getResult(money);
	cin.get();
	return 0;
}

抽象工廠

#include 
#include 
using namespace std;

//工廠模式：客戶類和工廠類分開。
//消費者任何時候需要某種產品，只需向工廠請求即可。

//消費者無須修改就可以接納新產品。缺點是當產品修改時，

//工廠類也要做相應的修改。如：如何創建及如何向客戶端提供。
//
//追MM少不了請吃飯了，麥當勞的雞翅和肯德基的雞翅都是MM愛吃的東西，
//雖然口味有所不同，但不管你帶MM去麥當勞或肯德基，
//只管向服務員說“來四個雞翅”就行了。麥當勞和肯德基就是生產雞翅的Factory。


//消費者不固定，工廠者不固定，（工廠根據消費者的行為進行動作）

//實現消費者抽象基類，消費者派生類的實現，實例化就是消費者

//操作的抽象基類，實現派生類各種操作，實例化的操作
//工廠的抽象類，抽象類包含了兩個抽象類的接口（消費者，操作）
//抽象類實現了工廠類的抽象，實例化的派生類，實現工廠，
//根據用戶設置用戶，根據操作設置操作

class IUser
{
public:
	virtual void getUser() = 0;  //純虛接口類，抽象類
	virtual void setUser() = 0;
};

class SqlUser :public IUser   //繼承抽象實現sql數據庫使用者的實例化
{
public:
	void getUser()
	{
		cout << "在sql中返回user" << endl;
	}
	void setUser()
	{
		cout << "在sql中設置user" << endl;
	}
};

class AccessUser :public IUser //繼承抽象實現access數據庫使用者的實例化
{
public:
	void getUser()
	{
		cout << "在Access中返回user" << endl;
	}
	void setUser()
	{
		cout << "在Access中設置user" << endl;
	}
};

class IDepartment  //抽象類，提供接口
{
public:
	virtual void getDepartment() = 0;
	virtual void setDepartment() = 0;
};

class SqlDepartment :public IDepartment  //SQL操作的實現
{
public:
	void getDepartment()
	{
		cout << "在sql中返回Department" << endl;
	}
	void setDepartment()
	{
		cout << "在sql中設置Department" << endl;
	}
};

class AccessDepartment :public IDepartment //access操作的實現
{
public:
	void getDepartment()
	{
		cout << "在Access中返回Department" << endl;
	}
	void setDepartment()
	{
		cout << "在Access中設置Department" << endl;
	}
};

class IFactory     //抽象工廠
{
public:
	virtual IUser *createUser() = 0;
	virtual IDepartment *createDepartment() = 0;
};

class SqlFactory :public IFactory  //抽象工廠一個實現
{
public:
	IUser *createUser()
	{
		return new SqlUser();
	}
	IDepartment *createDepartment()
	{
		return new SqlDepartment();
	}
};

class AccessFactory :public IFactory // 抽象工廠一個實現
{
public:
	IUser *createUser()
	{
		return new AccessUser();
	}
	IDepartment *createDepartment()
	{
		return new AccessDepartment();
	}
};

/*************************************************************/
//變相的實現了靜態類
class DataAccess
{
private:
	static string db;
	//string db="access";
public:
	static IUser *createUser()
	{
		if (db == "access")
		{
			return new AccessUser();
		}
		else if (db == "sql")
		{
			return new SqlUser();
		}
	}
	static IDepartment *createDepartment()
	{
		if (db == "access")
		{
			return new AccessDepartment();
		}
		else if (db == "sql")
		{
			return new SqlDepartment();
		}
	}
};

string DataAccess::db = "sql";
/*************************************************************/


int main()
{
	//IFactory *factory=new SqlFactory();
	IFactory *factory;//抽象工廠
	IUser *user;//抽象消費者
	IDepartment *department;//提供的操作

	factory = new AccessFactory();//基類的指針指指向派生類的對象
	user = factory->createUser();//基類的指針指向派生類的對象
	department = factory->createDepartment();//基類的指針指向派生類的對象

	user->getUser();
	user->setUser();//訪問acesss接口

	department->getDepartment();
	department->setDepartment();//接口

	user = DataAccess::createUser();
	department = DataAccess::createDepartment();

	user->getUser();
	user->setUser();
	department->getDepartment();
	department->setDepartment();

	cin.get();
	return 0;
}

工廠方法模式

#include 
#include 
using namespace std;

//工廠方法模式：核心工廠類不再負責所有產品的創建，
//而是將具體創建的工作交給子類去做，成為一個抽象工廠角色
//，僅負責給出具體工廠類必須實現的接口，
//而不接觸哪一個產品類應當被實例化這種細節。

//請MM去麥當勞吃漢堡，不同的MM有不同的口味，
//要每個都記住是一件煩人的事情，我一般采用Factory Method模式，
//帶著MM到服務員那兒，說“要一個漢堡”，具體要什麼樣的漢堡呢，
//讓MM直接跟服務員說就行了。

class Operation
{
public:
	double numberA, numberB;
	virtual double  getResult()//
	{
		return 0;
	}
};

class addOperation :public Operation
{
	double getResult()
	{
		return numberA + numberB;
	}
};

class subOperation :public Operation
{
	double getResult()
	{
		return numberA - numberB;
	}
};

class mulOperation :public Operation
{
	double getResult()
	{
		return numberA*numberB;
	}
};

class divOperation :public Operation
{
	double getResult()
	{
		return numberA / numberB;
	}
};

class IFactory
{
public:
	virtual Operation *createOperation() = 0;
};


class AddFactory :public IFactory
{
public:
	static Operation *createOperation()
	{
		return new addOperation();
	}
};

class SubFactory :public IFactory
{
public:
	static Operation *createOperation()
	{
		return new subOperation();
	}
};

class MulFactory :public IFactory
{
public:
	static Operation *createOperation()
	{
		return new mulOperation();
	}
};

class DivFactory :public IFactory
{
public:
	static Operation *createOperation()
	{
		return new divOperation();
	}
};

int mainw()
{
	Operation *oper = MulFactory::createOperation();
	oper->numberA = 9;
	oper->numberB = 99;
	cout << oper->getResult() << endl;
	cin.get();
	return 0;
}

簡單工廠模式

#include 
#include 
using namespace std;

//工廠模式：客戶類和工廠類分開。
//消費者任何時候需要某種產品，只需向工廠請求即可。
//消費者無須修改就可以接納新產品。缺點是當產品修改時，
//工廠類也要做相應的修改。如：如何創建及如何向客戶端提供。
//
//追MM少不了請吃飯了，麥當勞的雞翅和肯德基的雞翅都是MM愛吃的東西，
//雖然口味有所不同，但不管你帶MM去麥當勞或肯德基，
//只管向服務員說“來四個雞翅”就行了。麥當勞和肯德基就是生產雞翅的Factory。


//第一，基類存放數據
//第二，派生類有很多，派生類存放數據的操作
//第三實現接口類，用靜態函數實現調用各種派生類

class Operation    //基類存放數據
{
public:
	double numberA, numberB;//兩個數
	virtual double  getResult()//獲取結果
	{
		return 0;
	}
};

class addOperation :public Operation//派生類存放操作
{
	double getResult()
	{
		return numberA + numberB;
	}
};

class subOperation :public Operation
{
	double getResult()
	{
		return numberA - numberB;
	}
};

class mulOperation :public Operation
{
	double getResult()
	{
		return numberA*numberB;
	}
};

class divOperation :public Operation
{
	double getResult()
	{
		return numberA / numberB;
	}
};

class operFactory //實現調用改革吃哦啊做
{
public:
	static Operation *createOperation(char c)
	{
		switch (c)
		{
		case '+':
			return new addOperation;
			break;

		case '-':
			return new subOperation;
			break;

		case '*':
			return new mulOperation;
			break;

		case '/':
			return new divOperation;
			break;
		}
	}
};

int mainV()
{
	Operation *oper = operFactory::createOperation('-');
	oper->numberA = 9;
	oper->numberB = 99;
	cout << oper->getResult() << endl;

	cin.get();
	return 0;
}

代理模式

#include 
#include 
using namespace std;
//代理模式：代理模式給某一個對象提供一個代理對象，
//並由代理對象控制對源對象的引用。
//代理就是一個人或一個機構代表另一個人或者一個機構采取行動。
//某些情況下，客戶不想或者不能夠直接引用一個對象，
//代理對象可以在客戶和目標對象直接起到中介的作用。
//客戶端分辨不出代理主題對象與真實主題對象。
//代理模式可以並不知道真正的被代理對象，
//而僅僅持有一個被代理對象的接口，這時候代理對象不能夠創建被代理對象，
//被代理對象必須有系統的其他角色代為創建並傳入。
//跟MM在網上聊天，一開頭總是“hi, 你好”, 
//“你從哪兒來呀？”“你多大了？”“身高多少呀？”
//這些話，真煩人，寫個程序做為我的Proxy吧，
//凡是接收到這些話都設置好了自己的回答，
//接收到其他的話時再通知我回答，怎麼樣，酷吧。

class SchoolGirl
{
public:
	string name;
};

class IGiveGift
{
public:
	virtual void giveDolls() = 0;
	virtual void giveFlowers() = 0;
};

class Pursuit :public IGiveGift
{
private:
	SchoolGirl mm;
public:
	Pursuit(SchoolGirl m)
	{
		mm = m;
	}
	void giveDolls()
	{
		cout << mm.name << " 送你娃娃" << endl;
	}
	void giveFlowers()
	{
		cout << mm.name << " 送你鮮花" << endl;
	}
};

class Proxy :public IGiveGift
{
private:
	Pursuit gg;
public:
	Proxy(SchoolGirl mm) :gg(mm)
	{
		//gg=g;
	}
	void giveDolls()
	{
		gg.giveDolls();
	}
	void giveFlowers()
	{
		gg.giveFlowers();
	}
};

int mai12312321n()
{
	SchoolGirl lijiaojiao;
	lijiaojiao.name = "李嬌嬌";
	Pursuit zhuojiayi(lijiaojiao);
	Proxy daili(lijiaojiao);

	daili.giveDolls();
	cin.get();
	return 0;
}

單例模式

#include 
#include 
using namespace std;
//單例模式：單例模式確保某一個類只有一個實例，
//而且自行實例化並向整個系統提供這個實例單例模式
//。單例模式只應在有真正的“單一實例”的需求時才可使用。
//俺有6個漂亮的老婆，她們的老公都是我，
//我就是我們家裡的老公Sigleton，她們只要說道“老公”，
//都是指的同一個人，那就是我(剛才做了個夢啦，哪有這麼好的事)。
//#define  public private 

class 
{
public:
protected:
private:
}a1;

class Singleton
{
private:
	int i;
	static Singleton *instance;
	Singleton(int i)
	{
		this->i = i;
	}
public:
	static Singleton *getInstance()
	{
		return instance;
	}
	void show()
	{
		cout << i << endl;
	}
};
Singleton* Singleton::instance = new Singleton(8899);

class A :public Singleton
{

};

int mainJ()
{
	Singleton *s = Singleton::getInstance();
	Singleton *s2 = A::getInstance();
	cout << (s == s2) << endl;
	cin.get();
	return 0;
}

迭代器模式

#include 
#include 
using namespace std;
//迭代子模式：迭代子模式可以順序訪問一個聚集中的元素而不必暴露聚集的內部表象。
//多個對象聚在一起形成的總體稱之為聚集，聚集對象是能夠包容一組對象的容器對象。
//迭代子模式將迭代邏輯封裝到一個獨立的子對象中，從而與聚集本身隔開。
//迭代子模式簡化了聚集的界面。
//每一個聚集對象都可以有一個或一個以上的迭代子對象，
//每一個迭代子的迭代狀態可以是彼此獨立的。
//迭代算法可以獨立於聚集角色變化。
//我愛上了Mary，不顧一切的向她求婚。Mary：
//“想要我跟你結婚，得答應我的條件” 我：“什麼條件我都答應，你說吧”
//Mary：“我看上了那個一克拉的鑽石” 我：“我買，我買，還有嗎？”
//Mary：“我看上了湖邊的那棟別墅” 我：“我買，我買，還有嗎？”
//Mary：“我看上那輛法拉利跑車” 我腦袋嗡的一聲，坐在椅子上，一咬牙：
//“我買，我買，還有嗎？” ……
class Iterator;

class Aggregate
{
public:
	virtual Iterator *createIterator() = 0;
};

class Iterator
{
public:
	virtual void first() = 0;
	virtual void next() = 0;
	virtual bool isDone() = 0;
	virtual bool isDoneA() = 0;
	//virtual bool isDoneA() = 0;
};

class ConcreteAggregate :public Iterator
{
public:
	void first()
	{
	
	}
	void next()
	{
	}
	bool isDone()
	{
	
	}	
	virtual bool isDoneA()
	{

	}
};


int main12323I()
{

	cin.get();
	return 0;
}

訪問者模式

#include 
#include 
#include 
using namespace std;
//訪問者模式：訪問者模式的目的是封裝一些施加於某種數據結構元素之上的操作。
//一旦這些操作需要修改的話，接受這個操作的數據結構可以保持不變。
//訪問者模式適用於數據結構相對未定的系統，
//它把數據結構和作用於結構上的操作之間的耦合解脫開，
//使得操作集合可以相對自由的演化。訪問者模式使得增加新的操作變的很容易，
//就是增加一個新的訪問者類。
//訪問者模式將有關的行為集中到一個訪問者對象中，
//而不是分散到一個個的節點類中。當使用訪問者模式時，
//要將盡可能多的對象浏覽邏輯放在訪問者類中，而不是放到它的子類中。
//訪問者模式可以跨過幾個類的等級結構訪問屬於不同的等級結構的成員類。
//情人節到了，要給每個MM送一束鮮花和一張卡片，
//可是每個MM送的花都要針對她個人的特點，每張卡片也要根據個人的特點來挑，
//我一個人哪搞得清楚，還是找花店老板和禮品店老板做一下Visitor，
//讓花店老板根據MM的特點選一束花，讓禮品店老板也根據每個人特點選一張卡，
//這樣就輕松多了。
//訪問者模式不需要改變基類，不依賴虛函數，

class Person
{
public:
	char * action;
	virtual void getConclusion()
	{

	};
};

class Man :public Person
{
public:

	void getConclusion()
	{
		if (action == "成功")
		{
			cout << "男人成功時，背後多半有一個偉大的女人。" << endl;
		}
		else if (action == "戀愛")
		{
			cout << "男人戀愛時，凡事不懂裝懂。" << endl;
		}
	}
};

class Woman :public Person
{
public:

	void getConclusion()
	{
		if (action == "成功")
		{
			cout << "女人成功時，背後多半有失敗的男人。" << endl;
		}
		else if (action == "戀愛")
		{
			cout << "女人戀愛時，遇到事懂也裝不懂。" << endl;
		}
	}
};

int main132123()
{
	list persons;

	Person *man1 = new Man();
	man1->action = "成功";
	persons.push_back(man1);

	Person *woman1 = new Woman();
	woman1->action = "成功";
	persons.push_back(woman1);

	Person *man2 = new Man();
	man2->action = "戀愛";
	persons.push_back(man2);

	Person *woman2 = new Woman();
	woman2->action = "戀愛";
	persons.push_back(woman2);

	list::iterator iter = persons.begin();
	while (iter != persons.end())
	{
		(*iter)->getConclusion();
		++iter;
	}

	cin.get();
	return 0;
}

觀察者模式

#include 
#include 
#include 
using namespace std;

//觀察者模式：觀察者模式定義了一種一隊多的依賴關系，
//讓多個觀察者對象同時監聽某一個主題對象。
//這個主題對象在狀態上發生變化時，會通知所有觀察者對象，
//使他們能夠自動更新自己。
//想知道咱們公司最新MM情報嗎？加入公司的MM情報郵件組就行了，
//tom負責搜集情報，他發現的新情報不用一個一個通知我們，
//直接發布給郵件組，我們作為訂閱者（觀察者）就可以及時收到情報啦。
// 監視，觀察者，都有一個基類，派生，實現不同的效果
//監視者的類，管理所有的觀察者，增加或者刪除，發出消息，讓觀察者處理
//觀察者的類需要接受消息並處理

class Subject; //可以使用subject

class Observer
{
protected:
	string name;
	Subject *sub;
public:
	Observer(string name, Subject *sub)//觀察者的名字， 監視與通知的類
	{
		this->name = name;//輸入名字
		this->sub = sub;//設置誰來通知我
	}
	virtual void update() = 0;//純虛函數
};

class StockObserver :public Observer //繼承，自己實現刷新函數
{
public:
	StockObserver(string name, Subject *sub) :Observer(name, sub)
	{
	}
	void update();
};

class NBAObserver :public Observer
{
public:
	NBAObserver(string name, Subject *sub) :Observer(name, sub)
	{
	}
	void update();
};

class Subject  //
{
protected:
	list observers;///存儲觀察者的指針，鏈表
public:
	string action;
	virtual void attach(Observer*) = 0;
	virtual void detach(Observer*) = 0;
	virtual void notify() = 0;//實現監聽的基類
};

class Secretary :public Subject   
{
	void attach(Observer *observer)  //載入通知的列表
	{
		observers.push_back(observer);
	}
	void detach(Observer *observer)//刪除
	{
		list::iterator iter = observers.begin();
		while (iter != observers.end())
		{
			if ((*iter) == observer)
			{
				observers.erase(iter);
			}
			++iter;
		}
	}
	void notify()  ///通知函數
	{
		list::iterator iter = observers.begin();
		while (iter != observers.end())
		{
			(*iter)->update();
			++iter;
		}
	}
};

void StockObserver::update()
{
	cout << name << " 收到消息：" << sub->action << endl;
	if (sub->action == "梁所長來了!")
	{
		cout << "我馬上關閉股票，裝做很認真工作的樣子！" << endl;
	}
	if (sub->action == "去喝酒！")
	{
		cout << "我馬上走" << endl;
	}
}

void NBAObserver::update()
{
	cout << name << " 收到消息：" << sub->action << endl;
	if (sub->action == "梁所長來了!")
	{
		cout << "我馬上關閉NBA，裝做很認真工作的樣子！" << endl;
	}

   if (sub->action == "去喝酒！")
   {
	cout << "我馬上拍" << endl;
    }
}

int main123123()
{
	Subject *dwq = new Secretary();//消息監視，監視

	Observer *xs = new NBAObserver("xiaoshuai", dwq);//訂閱消息
	Observer *zy = new NBAObserver("zouyue", dwq);
	Observer *lm = new StockObserver("limin", dwq);

	dwq->attach(xs);
	dwq->attach(zy);
	dwq->attach(lm);//增加到隊列

	dwq->action = "去吃飯了！";
	dwq->notify();
	dwq->action = "去喝酒！";
	dwq->notify();
	cout << endl;
	dwq->action = "梁所長來了!";
	dwq->notify();
	cin.get();
	return 0;
}

建造者模式

#include 
#include 
#include 
using namespace std;
//建造模式：將產品的內部表象和產品的生成過程分割開來，
//從而使一個建造過程生成具有不同的內部表象的產品對象。
//建造模式使得產品內部表象可以獨立的變化，
//客戶不必知道產品內部組成的細節。
//建造模式可以強制實行一種分步驟進行的建造過程。
//MM最愛聽的就是“我愛你”這句話了，見到不同地方的MM，
//要能夠用她們的方言跟她說這句話哦，我有一個多種語言翻譯機，
//上面每種語言都有一個按鍵，見到MM我只要按對應的鍵，
//它就能夠用相應的語言說出“我愛你”這句話了，
//國外的MM也可以輕松搞掂，這就是我的“我愛你”builder。（
//這一定比美軍在伊拉克用的翻譯機好賣）

class Person  //抽象類，預留ule接口
{
public:
	virtual void createHead() = 0;
	virtual void createHand() = 0;
	virtual void createBody() = 0;
	virtual void createFoot() = 0;
};

class ThinPerson :public Person  ///實現抽象類瘦子，
{
	void createHead()
	{
		cout << "thin head" << endl;
	}
	void createHand()
	{
		cout << "thin hand" << endl;
	}
	void createBody()
	{
		cout << "thin body" << endl;
	}
	void createFoot()
	{
		cout << "thin foot" << endl;
	}
};

class FatPerson :public Person //胖子
{
	void createHead()
	{
		cout << "fat head" << endl;
	}
	void createHand()
	{
		cout << "fat hand" << endl;
	}
	void createBody()
	{
		cout << "fat body" << endl;
	}
	void createFoot()
	{
		cout << "fat foot" << endl;
	}
};


class Director
{
private:
	Person *p;//基類的指針
public:
	Director(Person *temp) //傳遞對象
	{
		p = temp;//虛函數實現多態
	}
	void create()
	{
		p->createHead();
		p->createHand();
		p->createBody();
		p->createFoot();
	}
};

//客戶端代碼：
int mainT()
{
	Person *p = new FatPerson();

	Director *d = new Director(p);
	d->create();
	delete d;
	delete p;

	cin.get();
	return 0;
}

解釋器模式

#include 
#include 
#include 
using namespace std;
//解釋器模式：給定一個語言後，解釋器模式可以定義出其文法的一種表示，
//並同時提供一個解釋器。客戶端可以使用這個解釋器來解釋這個語言中的句子。
//解釋器模式將描述怎樣在有了一個簡單的文法後，使用模式設計解釋這些語句。
//在解釋器模式裡面提到的語言是指任何解釋器對象能夠解釋的任何組合。
//在解釋器模式中需要定義一個代表文法的命令類的等級結構，
//也就是一系列的組合規則。每一個命令對象都有一個解釋方法，
//代表對命令對象的解釋。命令對象的等級結構中的對象的任何排列組合都是一個語言。
//俺有一個《泡MM真經》，上面有各種泡MM的攻略，比如說去吃西餐的步驟、
//去看電影的方法等等，跟MM約會時，只要做一個Interpreter，
//照著上面的腳本執行就可以了。

class Context;

class AbstractExpression
{
public:
	virtual void interpret(Context *) = 0;
};

class TerminalExpression :public AbstractExpression
{
public:
	void interpret(Context *context)
	{
		cout << "終端解釋器" << endl;
	}
};

class NonterminalExpression :public AbstractExpression
{
public:
	void interpret(Context *context)
	{
		cout << "非終端解釋器" << endl;
	}
};

class Context
{
public:
	string input, output;
};

int mainK()
{
	Context *context = new Context();
	list  lt;
	lt.push_back(new TerminalExpression());
	lt.push_back(new NonterminalExpression());
	lt.push_back(new TerminalExpression());
	lt.push_back(new TerminalExpression());

	for (list::iterator iter = lt.begin(); iter != lt.end(); iter++)
	{
		(*iter)->interpret(context);
	}

	cin.get();
	return 0;
}

命令模式

#include 
#include 
#include 
//命令模式：命令模式把一個請求或者操作封裝到一個對象中。
//命令模式把發出命令的責任和執行命令的責任分割開，委派給不同的對象。
//命令模式允許請求的一方和發送的一方獨立開來，
//使得請求的一方不必知道接收請求的一方的接口，
//更不必知道請求是怎麼被接收，
//以及操作是否執行，何時被執行以及是怎麼被執行的。
//系統支持命令的撤消。
//俺有一個MM家裡管得特別嚴，沒法見面，只好借助於她弟弟在我們倆之間傳送信息，
//她對我有什麼指示，就寫一張紙條讓她弟弟帶給我。這不，
//她弟弟又傳送過來一個COMMAND，為了感謝他，我請他吃了碗雜醬面，
//哪知道他說：“我同時給我姐姐三個男朋友送COMMAND，就數你最小氣，
//才請我吃面。”
//
using namespace std;

class Barbecuer  //接收者執行命令
{
public:
	void bakeMutton()
	{
		cout << "烤羊肉串" << endl;
	}
	void bakeChickenWing()
	{
		cout << "烤雞翅" << endl;
	}
};

class Command   //命令基類
{
protected:
	Barbecuer *receiver;//類的包含
public:
	Command(Barbecuer *receiver)//命令接受
	{
		this->receiver = receiver;
	}
	virtual void executeCommand() = 0;
};

class BakeMuttonCommand :public Command  //命令傳送著
{
public:
	BakeMuttonCommand(Barbecuer *receiver) :Command(receiver)
	{}
	void executeCommand()
	{
		receiver->bakeMutton();
	}
};

class BakeChikenWingCommand :public Command  //命令傳送著
{
public:
	BakeChikenWingCommand(Barbecuer *receiver) :Command(receiver)
	{}
	void executeCommand()
	{
		receiver->bakeChickenWing();
	}
};

class Waiter        //服務員
{
private:
	Command *command;
public:
	void setOrder(Command *command)
	{
		this->command = command;
	}
	void notify()
	{
		command->executeCommand();
	}
};

class Waiter2   //gei多個對象下達命令
{
private:
	list orders;
public:
	void setOrder(Command *command)
	{
		orders.push_back(command);
	}
	void cancelOrder(Command *command)
	{}
	void notify()
	{
		list::iterator iter = orders.begin();
		while (iter != orders.end())
		{
			(*iter)->executeCommand();
			iter++;
		}
	}
};


int main1232131231()
{

	Barbecuer *boy = new Barbecuer();
	Command *bm1 = new BakeMuttonCommand(boy);
	Command *bm2 = new BakeMuttonCommand(boy);
	Command *bc1 = new BakeChikenWingCommand(boy);

	Waiter2 *girl = new Waiter2();

	girl->setOrder(bm1);
	girl->setOrder(bm2);
	girl->setOrder(bc1);

	girl->notify();


	cin.get();

	return 0;
}

模板模式

#include
#include 
#include 
using namespace std;
/*模板方法模式：模板方法模式准備一個抽象類，
將部分邏輯以具體方法以及具體構造子的形式實現，
然後聲明一些抽象方法來迫使子類實現剩余的邏輯。
不同的子類可以以不同的方式實現這些抽象方法，
從而對剩余的邏輯有不同的實現。先制定一個頂級邏輯框架，
而將邏輯的細節留給具體的子類去實現。

女生從認識到得手的不變的步驟分為巧遇、打破僵局、展開追求、接吻、得手
但每個步驟針對不同的情況，都有不一樣的做法，這就要看你隨機應變啦(具體實現)*/

class AbstractClass
{
public:
	void Show()
	{
		cout << "我是" << GetName() << endl;
	}
protected:
	virtual string GetName() = 0;
};

class Naruto : public AbstractClass
{
protected:
	virtual string GetName()
	{
		return "火影史上最帥的六代目---一鳴驚人naruto";
	}
};

class OnePice : public AbstractClass
{
protected:
	virtual string GetName()
	{
		return "我是無惡不做的大海賊---路飛";
	}
};

//客戶端
int mainP13()
{
	Naruto* man = new Naruto();
	man->Show();

	OnePice* man2 = new OnePice();
	man2->Show();

	cin.get();
	return 0;
}

橋接模式

#include 
#include 
using namespace std;
//橋梁模式：將抽象化與實現化脫耦，使得二者可以獨立的變化，
//也就是說將他們之間的強關聯變成弱關聯，
//也就是指在一個軟件系統的抽象化和實現化之間使用組合 
/// 聚合關系而不是繼承關系，從而使兩者可以獨立的變化。
//早上碰到MM，要說早上好，晚上碰到MM，要說晚上好；
//碰到MM穿了件新衣服，要說你的衣服好漂亮哦，碰到MM新做的發型，
//要說你的頭發好漂亮哦。不要問我“早上碰到MM新做了個發型怎麼說”
//這種問題，自己用BRIDGE組合一下不就行了。

class HandsetSoft
{
public:
	virtual void run() = 0;
};

class HandsetGame :public HandsetSoft
{
public:
	void run()
	{
		cout << "運行手機游戲" << endl;
	}
};

class HandsetAddressList :public HandsetSoft
{
public:
	void run()
	{
		cout << "運行手機通訊錄" << endl;
	}
};

class HandsetBrand
{
protected:
	HandsetSoft *soft;
public:
	void setHandsetSoft(HandsetSoft *soft)
	{
		this->soft = soft;
	}
	virtual void run() = 0;
};

class HandsetBrandN :public HandsetBrand
{
public:
	void run()
	{
		soft->run();
	}
};

class HandsetBrandM :public HandsetBrand
{
public:
	void run()
	{
		soft->run();
	}
};

int mainS()
{
	HandsetBrand *hb;
	hb = new HandsetBrandM();

	hb->setHandsetSoft(new HandsetGame());
	hb->run();
	hb->setHandsetSoft(new HandsetAddressList());
	hb->run();

	cin.get();
	return 0;
}

適配器模式

#include 
#include 
using namespace std;
//適配器（變壓器）模式：把一個類的接口變換成客戶端所期待的另一種接口
//，從而使原本因接口原因不匹配而無法一起工作的兩個類能夠一起工作。
//適配類可以根據參數返還一個合適的實例給客戶端。
//
//在朋友聚會上碰到了一個美女Sarah，從香港來的，
//可我不會說粵語，她不會說普通話，只好求助於我的朋友kent了，
//他作為我和Sarah之間的Adapter，讓我和Sarah可以相互交談了
//(也不知道他會不會耍我)。

class Player
{
public:
	string name;
	Player(string name)
	{
		this->name = name;
	}
	virtual void attack() = 0;
	virtual void defence() = 0;
};

class Forwards :public Player
{
public:
	Forwards(string name) :Player(name){}
	void attack()
	{
		cout << name << " 前鋒進攻" << endl;
	}
	void defence()
	{
		cout << name << " 前鋒防守" << endl;
	}
};

class Center :public Player
{
public:
	Center(string name) :Player(name){}
	void attack()
	{
		cout << name << " 中鋒進攻" << endl;
	}
	void defence()
	{
		cout << name << " 中鋒防守" << endl;
	}
};

class Backwards :public Player
{
public:
	Backwards(string name) :Player(name){}
	void attack()
	{
		cout << name << " 後衛進攻" << endl;
	}
	void defence()
	{
		cout << name << " 後衛防守" << endl;
	}
};
/*****************************************************************/
class ForeignCenter
{
public:
	string name;
	ForeignCenter(string name)
	{
		this->name = name;
	}
	void myAttack()
	{
		cout << name << " 外籍中鋒進攻" << endl;
	}
	void myDefence()
	{
		cout << name << " 外籍後衛防守" << endl;
	}
};
/*****************************************************************/
class Translator :public Player
{
private:
	ForeignCenter *fc;
public:
	Translator(string name) :Player(name)
	{
		fc = new ForeignCenter(name);
	}
	void attack()
	{
		fc->myAttack();
	}
	void defence()
	{
		fc->myDefence();
	}
};
/*****************************************************************/
int mainM()
{
	Player *p1 = new Center("李俊宏");
	p1->attack();
	p1->defence();

	Translator *tl = new Translator("姚明");
	tl->attack();
	tl->defence();
	cin.get();
	return 0;
}

外觀模式

#include 
#include 
using namespace std;
//門面模式：外部與一個子系統的通信必須通過一個統一的門面對象進行。
//門面模式提供一個高層次的接口，使得子系統更易於使用。
//每一個子系統只有一個門面類，而且此門面類只有一個實例，
//也就是說它是一個單例模式。但整個系統可以有多個門面類。
//
//我有一個專業的Nikon相機，我就喜歡自己手動調光圈、快門，
//這樣照出來的照片才專業，但MM可不懂這些，教了半天也不會。
//幸好相機有Facade設計模式，把相機調整到自動檔，
//只要對准目標按快門就行了，一切由相機自動調整，
//這樣MM也可以用這個相機給我拍張照片了。

class Sub1
{
public:
	void f1()
	{
		cout << "子系統的方法 1" << endl;
	}
};

class Sub2
{
public:
	void f2()
	{
		cout << "子系統的方法 2" << endl;
	}
};

class Sub3
{
public:
	void f3()
	{
		cout << "子系統的方法 3" << endl;
	}
};

class Facade
{
private:
	Sub1 *s1;
	Sub2 *s2;
	Sub3 *s3;
public:
	Facade()
	{
		s1 = new Sub1();
		s2 = new Sub2();
		s3 = new Sub3();
	}
	void method()
	{
		s1->f1();
		s2->f2();
		s3->f3();
	}
};

int mainB ()
{
	Facade *f = new Facade();
	f->method(); 
	cin.get();
	return 0;
}

享元模式

#include 
#include 
#include 
#include
using namespace std;

//享元模式：FLYWEIGHT在拳擊比賽中指最輕量級。
//享元模式以共享的方式高效的支持大量的細粒度對象。
//享元模式能做到共享的關鍵是區分內蘊狀態和外蘊狀態。
//內蘊狀態存儲在享元內部，不會隨環境的改變而有所不同。
//外蘊狀態是隨環境的改變而改變的。外蘊狀態不能影響內蘊狀態，
//它們是相互獨立的。將可以共享的狀態和不可以共享的狀態從常規類中區分開來，
//將不可以共享的狀態從類裡剔除出去。客戶端不可以直接創建被共享的對象，
//而應當使用一個工廠對象負責創建被共享的對象。
//享元模式大幅度的降低內存中對象的數量。
//
//每天跟MM發短信，手指都累死了，最近買了個新手機，
//可以把一些常用的句子存在手機裡，要用的時候，直接拿出來
//，在前面加上MM的名字就可以發送了，再不用一個字一個字敲了。
//共享的句子就是Flyweight，MM的名字就是提取出來的外部特征，
//根據上下文情況使用。

class WebSite
{
public:
	virtual void use() = 0;//預留接口實現功能
};

class ConcreteWebSite :public WebSite
{
private:
	string name;
public:
	ConcreteWebSite(string name)//實例化
	{
		this->name = name;
	}
	void use()
	{
		cout << "網站分類: " << name << endl;
	}
};

class WebSiteFactory
{
private:
	map wf;
public:

	WebSite *getWebSiteCategory(string key)
	{

		if (wf.find(key) == wf.end())
		{
			wf[key] = new ConcreteWebSite(key);
		}

		return wf[key];
	}

	int getWebSiteCount()
	{
		return wf.size();
	}
};

int main123qweqe()
{
	WebSiteFactory *wf = new WebSiteFactory();

	WebSite *fx = wf->getWebSiteCategory("good");
	fx->use();

	WebSite *fy = wf->getWebSiteCategory("產品展示");
	fy->use();

	WebSite *fz = wf->getWebSiteCategory("產品展示");
	fz->use();


	WebSite *f1 = wf->getWebSiteCategory("博客");
	f1->use();

	WebSite *f2 = wf->getWebSiteCategory("博客");
	f2->use();

	cout << wf->getWebSiteCount() << endl;

	cin.get();
	return 0;
}

原型模式

#include 
#include 
using namespace std;
//原型模式允許動態的增加或減少產品類，
//產品類不需要非得有任何事先確定的等級結構，
//原始模型模式適用於任何的等級結構。
//缺點是每一個類都必須配備一個克隆方法。


//跟MM用QQ聊天，一定要說些深情的話語了，
//我搜集了好多肉麻的情話，需要時只要copy出來放到QQ裡面就行了，
//這就是我的情話prototype了。
//原型模式：通過給出一個原型對象來指明所要創建的對象的類型，
//然後用復制這個原型對象的方法創建出更多同類型的對象。

class Resume
{
private:
	string name, sex, age, timeArea, company;
public:
	Resume(string s)
	{
		name = s;
	}
	void setPersonalInfo(string s, string a)
	{
		sex = s;
		age = a;
	}
	void setWorkExperience(string t, string c)
	{
		timeArea = t;
		company = c;
	}
	void display()
	{
		cout << name << "  " << sex << "  " << age << endl;
		cout << "工作經歷:  " << timeArea << "  " << company << endl << endl;

	}
	Resume *clone()
	{
		Resume *b;
		b = new Resume(name);
		b->setPersonalInfo(sex, age);
		b->setWorkExperience(timeArea, company);
		return b;
	}
};


int main213123()
{
	Resume *r = new Resume("李彥宏");
	r->setPersonalInfo("男", "30");
	r->setWorkExperience("2007-2010", "讀研究生");
	r->display();


	Resume *r2 = r->clone();
	r2->setWorkExperience("2003-2007", "讀本科");

	r->display();
	r2->display();

	cin.get();
	return 0;
}

責任鏈模式

#include
#include 
using namespace std;

//責任鏈模式：在責任鏈模式中，很多對象由每一個對象對其下家的引用而接起來形成
//一條鏈。請求在這個鏈上傳遞，直到鏈上的某一個對象決定處理此請求。
//客戶並不知道鏈上的哪一個對象最終處理這個請求，系統可以在不影響客戶端的
//情況下動態的重新組織鏈和分配責任。處理者有兩個選擇：承擔責任或者把責任
//推給下家。一個請求可以最終不被任何接收端對象所接受。
//
//晚上去上英語課，為了好開溜坐到了最後一排，哇，前面坐了好幾個漂亮的MM哎，
//找張紙條，寫上“Hi, 可以做我的女朋友嗎？如果不願意請向前傳”，
//紙條就一個接一個的傳上去了，糟糕，傳到第一排的MM把紙條傳給老師了，
//聽說是個老處女呀，快跑!

class Request  //請求
{
public:
	string requestType;
	string requestContent;
	int number;
};

class Manager  ///管理者
{
protected:
	string name;
	Manager *superior;
public:
	Manager(string name)
	{
		this->name = name;
	}
	void setSuperior(Manager *superior)
	{
		this->superior = superior;
	}
	virtual void requestApplications(Request *request) = 0;
};

class CommonManager :public Manager  //經理
{
public:
	CommonManager(string name) :Manager(name)
	{}
	void requestApplications(Request *request)
	{
		if (request->requestType == "請假" && request->number <= 2)
		{
			cout << name << " " << request->requestContent << " 數量: " << request->number << "被批准" << endl;
		}
		else
		{
			if (superior != NULL)
			{
				superior->requestApplications(request);
			}
		}
	}
};

class Majordomo :public Manager  //總監
{
public:
	Majordomo(string name) :Manager(name)
	{}
	void requestApplications(Request *request)
	{
		if (request->requestType == "請假" && request->number <= 5)
		{
			cout << name << " " << request->requestContent << " 數量: " << request->number << "被批准" << endl;
		}
		else
		{
			if (superior != NULL)
			{
				superior->requestApplications(request);
			}
		}
	}
};


class GeneralManager :public Manager //總經理
{
public:
	GeneralManager(string name) :Manager(name)
	{}
	void requestApplications(Request *request)
	{
		if (request->requestType == "請假")
		{
			cout << name << " " << request->requestContent << " 數量: " << request->number << "被批准" << endl;
		}
	}
};


int main123213123213()
{
	CommonManager *jinli = new CommonManager("經理");
	Majordomo *zongjian = new Majordomo("總監");
	GeneralManager *zhongjingli = new GeneralManager("總經理");

	jinli->setSuperior(zongjian);
	zongjian->setSuperior(zhongjingli);

	Request *request = new Request();

	request->requestType = "請假";
	request->requestContent = "李俊宏請假";
	request->number = 1;
	jinli->requestApplications(request);


	request->requestType = "請假";
	request->requestContent = "李俊宏請假";
	request->number = 4;
	jinli->requestApplications(request);


	request->requestType = "請假";
	request->requestContent = "李俊宏請假";
	request->number = 10;
	jinli->requestApplications(request);

	cin.get();
	return 0;
}

中介者模式

#include
#include 
using namespace std;
////MEDIATOR 調停者模式
//
////調停者模式：調停者模式包裝了一系列對象相互作用的方式，
//使得這些對象不必相互明顯作用。從而使他們可以松散偶合。
//當某些對象之間的作用發生改變時，不會立即影響其他的一些對象之間的作用。
//保證這些作用可以彼此獨立的變化。調停者模式將多對多的相互作用轉化
//為一對多的相互作用。調停者模式將對象的行為和協作抽象化
//，把對象在小尺度的行為上與其他對象的相互作用分開處理。
//
////四個MM打麻將，相互之間誰應該給誰多少錢算不清楚了，
//幸虧當時我在旁邊，按照各自的籌碼數算錢，賺了錢的從我這裡拿，
//賠了錢的也付給我，一切就OK啦，俺得到了四個MM的電話。
//
////中介者模式，找不到老婆可以相親靠婚介

class Country;

class UniteNations
{
public:
	virtual void declare(string message, Country *colleague) = 0;
};

class Country
{
protected:
	UniteNations *mediator;
public:
	Country(UniteNations *mediator)
	{
		this->mediator = mediator;
	}
};

class USA :public Country
{
public:
	USA(UniteNations *mediator) :Country(mediator)
	{}
	void declare(string message)
	{
		cout << "美發布信息: " << message << endl;
		mediator->declare(message, this);
	}
	void getMessage(string message)
	{
		cout << "美國獲得對方信息: " << message << endl;
	}
};

class Iraq :public Country
{
public:
	Iraq(UniteNations *mediator) :Country(mediator)
	{}
	void declare(string message)
	{
		cout << "伊拉克發布信息: " << message << endl;
		mediator->declare(message, this);
	}
	void getMessage(string message)
	{
		cout << "伊拉克獲得對方信息: " << message << endl;
	}
};

class UnitedNationsSecurityCouncil :public UniteNations
{
public:
	USA *usa;
	Iraq *iraq;
	void declare(string message, Country *colleague)
	{
		if (colleague == usa)
		{
			iraq->getMessage(message);
		}
		else
		{
			usa->getMessage(message);
		}
	}
};

int mainWERT()
{
	UnitedNationsSecurityCouncil *unsc = new UnitedNationsSecurityCouncil();

	USA *c1 = new USA(unsc);
	Iraq *c2 = new Iraq(unsc);

	unsc->usa = c1;
	unsc->iraq = c2;

	c1->declare("不准開發核武器，否則打你！");
	c2->declare("他媽的美國去死！");

	cin.get();
	return 0;
}

裝飾模式

#include 
#include 
using namespace std;

//裝飾模式：裝飾模式以對客戶端透明的方式擴展對象的功能，
//是繼承關系的一個替代方案，提供比繼承更多的靈活性。
//動態給一個對象增加功能，這些功能可以再動態的撤消。
//增加由一些基本功能的排列組合而產生的非常大量的功能。
//
//Mary過完輪到Sarly過生日，還是不要叫她自己挑了，
//不然這個月伙食費肯定玩完，拿出我去年在華山頂上照的照片，
//在背面寫上“最好的的禮物，就是愛你的Fita”，
//再到街上禮品店買了個像框（賣禮品的MM也很漂亮哦），
//再找隔壁搞美術設計的Mike設計了一個漂亮的盒子裝起來……，
//我們都是Decorator，最終都在修飾我這個人呀，怎麼樣，看懂了嗎？

class Person
{
private:
	string m_strName;
public:
	Person(string strName)
	{
		m_strName = strName;
	}
	Person(){}
	virtual void show()
	{
		cout << "裝扮的是:" << m_strName << endl;
	}
};

class Finery :public Person
{
protected:
	Person *m_component;
public:
	void decorate(Person* component)
	{
		m_component = component;
	}
	virtual void show()
	{
		m_component->show();
	}
};

class TShirts :public Finery
{
public:
	virtual void show()
	{
		m_component->show();
		cout << "T shirts" << endl;
	}
};

class BigTrouser :public Finery
{
public:
	virtual void show()
	{
		m_component->show();
		cout << "Big Trouser" << endl;
	}
};

int mainE()
{
	Person *p = new Person("小李");
	BigTrouser *bt = new BigTrouser();
	TShirts *ts = new TShirts();

	bt->decorate(p);
	ts->decorate(bt);
	ts->show();
	cin.get();
	return 0;
}

狀態模式

#include 
#include 
using namespace std;
//狀態模式：狀態模式允許一個對象在其內部狀態改變的時候改變行為。
//這個對象看上去象是改變了它的類一樣。狀態模式把所研究的對象的行
//為包裝在不同的狀態對象裡，每一個狀態對象都屬於一個抽象狀態類的
//一個子類。狀態模式的意圖是讓一個對象在其內部狀態改變的時候，
//其行為也隨之改變。狀態模式需要對每一個系統可能取得的狀態創立一個狀態類的
//子類。當系統的狀態變化時，系統便改變所選的子類。
//
//跟MM交往時，一定要注意她的狀態哦，在不同的狀態時她的行為會有不同，
//比如你約她今天晚上去看電影，對你沒興趣的MM就會說“有事情啦”
//，對你不討厭但還沒喜歡上的MM就會說“好啊，不過可以帶上我同事麼？”
//，已經喜歡上你的MM就會說“幾點鐘？看完電影再去泡吧怎麼樣？”，
//當然你看電影過程中表現良好的話，也可以把MM的狀態從不討厭不喜歡變成喜歡哦。

class Work;
class State;
class ForenonnState;

class State
{
public:
	virtual void writeProgram(Work*) = 0;//准櫃台的基類，抽象類
};

class Work   //實施工作的類，根據狀態執行不同的操作
{
public:
	int hour;
	State *current;
	Work();
	
	
	void writeProgram()
	{
		current->writeProgram(this);
	}
};

class EveningState :public State  //晚上狀態
{
public:
	void writeProgram(Work *w)
	{
		cout << "當前時間: " << w->hour << "心情很好，在看《明朝那些事兒》，收獲很大！" << endl;
	}
};

class AfternoonState :public State  
{
public:
	void writeProgram(Work *w)
	{
		if (w->hour < 19)
		{
			cout << "當前時間: " << w->hour << "下午午睡後，工作還是精神百倍!" << endl;
		}
		else
		{
			w->current = new EveningState();
			w->writeProgram();
		}
	}
};

class ForenonnState :public State
{
public:
	void writeProgram(Work *w)
	{
		if (w->hour < 12)
		{
			cout << "當前時間: " << w->hour << "上午工作精神百倍!" << endl;
		}
		else
		{
			w->current = new AfternoonState();
			w->writeProgram();
		}
	}
};

Work::Work()
{
	current = new ForenonnState();
}


int mainD()
{
	Work *w = new Work();
	w->hour = 21;
	w->writeProgram();
	cin.get();
	return 0;
}

組合模式

#include 
#include 
#include 
using namespace std;
//合成模式：合成模式將對象組織到樹結構中，可以用來描述整體與部分的關系。
//合成模式就是一個處理對象的樹結構的模式。合成模式把部分與整體的關系用樹結構表示出來。
//合成模式使得客戶端把一個個單獨的成分對象和由他們復合而成的合成對象同等看待。
//
//Mary今天過生日。“我過生日，你要送我一件禮物。”
//嗯，好吧，去商店，你自己挑。”
//“這件T恤挺漂亮，買，這條裙子好看，買，這個包也不錯，買
//。”“喂，買了三件了呀，我只答應送一件禮物的哦。
//”“什麼呀，T恤加裙子加包包，正好配成一套呀，小姐，麻煩你包起來。
//”“……”，MM都會用Composite模式了，你會了沒有？

class Component
{
public:
	string name;
	Component(string name)
	{
		this->name = name;
	}
	virtual void add(Component *) = 0;
	virtual void remove(Component *) = 0;
	virtual void display(int) = 0;
};

class Leaf :public Component
{
public:
	Leaf(string name) :Component(name)
	{}
	void add(Component *c)
	{
		cout << "leaf cannot add" << endl;
	}
	void remove(Component *c)
	{
		cout << "leaf cannot remove" << endl;
	}
	void display(int depth)
	{
		string str(depth, '-');
		str += name;
		cout << str << endl;
	}
};

class Composite :public Component
{
private:
	vector component;
public:
	Composite(string name) :Component(name)
	{}
	void add(Component *c)
	{
		component.push_back(c);
	}
	void remove(Component *c)
	{
		vector::iterator iter = component.begin();
		while (iter != component.end())
		{
			if (*iter == c)
			{
				component.erase(iter);
			}
			iter++;
		}
	}
	void display(int depth)
	{
		string str(depth, '-');
		str += name;
		cout << str << endl;

		vector::iterator iter = component.begin();
		while (iter != component.end())
		{
			(*iter)->display(depth + 2);
			iter++;
		}
	}
};


int main()
{
	Component *p = new Composite("小李");
	p->add(new Leaf("小王"));
	p->add(new Leaf("小強"));

	Component *sub = new Composite("小虎");
	sub->add(new Leaf("小王"));
	sub->add(new Leaf("小明"));
	sub->add(new Leaf("小柳"));

	p->add(sub);
	p->display(0);

	cout << "*******" << endl;
	sub->display(2);

	cin.get();

	return 0;
}