23種GOF設計模式一般分為三大類：建立型模式、結構型模式、行為模式。
建立型模式抽象了執行個體化過程，它們幫助一個系統獨立于怎樣建立、組合和表示它的那些對象。一個類建立型模式使用繼承改變被執行個體化的類，而一個對象建立型模式将執行個體化托付給還有一個對象。建立型模式有兩個不斷出現的主旋律。
第一，它們都将關于該系統使用哪些詳細的類的資訊封裝起來。第二，它們隐藏了這些類的執行個體是怎樣被建立和放在一起的。整個系統關于這些對象所知道的是由抽象類所定義的接口。
是以。建立型模式在什麼被建立。誰建立它，它是怎樣被建立的。以及何時建立這些方面給予了非常大的靈活性。它們同意用結構和功能差別非常大的“産品”對象配置一個系統。配置能夠是靜态的(即在編譯時指定)，也能夠是動态的(在執行時)。
結構型模式涉及到怎樣組合類和對象以獲得更大的結構。
結構型類模式採用繼承機制來組合接口或實作。
結構型對象模式不是對接口和實作進行組合，而是描寫叙述了怎樣對一些對象進行組合，進而實作新功能的一些方法。由于能夠在執行時刻改變對象組合關系，是以對象組合方式具有更大的靈活性。而這樣的機制用靜态類組合是不可能實作的。
行為模式涉及到算法和對象間職責的配置設定。行為模式不僅描寫叙述對象或類的模式。還描寫叙述它們之間的通信模式。這些模式刻畫了在執行時難以跟蹤的複雜的控制流。它們将使用者的注意力從控制流轉移到對象間的聯系方式上來。行為類模式使用繼承機制在類間分派行為。
行為對象模式使用對象複合而不是繼承。
一些行為對象模式描寫叙述了一組對等的對象怎樣互相協作以完畢當中任一個對象都無法單獨完畢的任務。
建立型模式包含：1、FactoryMethod(工廠方法模式)；2、Abstract Factory(抽象工廠模式)；3、Singleton(單例模式)；4、Builder(建造者模式、生成器模式)。5、Prototype(原型模式).
結構型模式包含：6、Bridge(橋接模式)；7、Adapter(擴充卡模式)。8、Decorator(裝飾模式)；9、Composite(組合模式)。10、Flyweight(享元模式)；11、Facade(外觀模式)；12、Proxy(代理模式).
行為模式包含：13、TemplateMethod(模闆方法模式)；14、Strategy(政策模式)。15、State(狀态模式)；16、Observer(觀察者模式)；17、Memento(備忘錄模式)；18、Mediator(中介者模式)；19、Command(指令模式)。20、Visitor(訪問者模式)；21、Chain of Responsibility(責任鍊模式)；22、Iterator(疊代器模式)；23、Interpreter(解釋器模式).
Factory Method：定義一個用于建立對象的接口。讓子類決定将哪一個類執行個體化。Factory Method使一個類的執行個體化延遲到其子類。
Abstract Factory：提供一個建立一系列相關或互相依賴對象的接口。而無需指定他們詳細的類。
Singleton：保證一個類僅有一個執行個體，并提供一個訪問它的全局訪問點。
Builder：将一個複雜對象的建構與它的表示分離，使得相同的建構過程能夠建立不同的表示。
Prototype：用原型執行個體指定建立對象的種類。而且通過拷貝這個原型來建立新的對象。
Bridge：将抽象部分與它的實作部分分離，使它們都能夠獨立地變化。
Adapter：将一個類的接口轉換成客戶希望的另外一個接口。
Adapter模式使得原本由于接口不相容而不能一起工作的那些類能夠一起工作。
Decorator：動态地給一個對象加入一些額外的職責。就擴充功能而言， Decorator模式比生成子類方式更為靈活。
Composite：将對象組合成樹形結構以表示“部分-總體”的層次結構。
Composite使得客戶對單個對象和複合對象的使用具有一緻性。
Flyweight：運用共享技術有效地支援大量細粒度的對象。
Facade：為子系統中的一組接口提供一個一緻的界面， Facade模式定義了一個高層接口，這個接口使得這一子系統更加easy使用。
Proxy：為其它對象提供一個代理以控制對這個對象的訪問。
Template Method：定義一個操作中的算法的骨架。而将一些步驟延遲到子類中。Template Method使得子類能夠不改變一個算法的結構就可以重定義該算法的某些特定步驟。
Strategy：定義一系列的算法,把它們一個個封裝起來, 而且使它們可互相替換。本模式使得算法的變化可獨立于使用它的客戶。
State：同意一個對象在其内部狀态改變時改變它的行為。對象看起來似乎改動了它所屬的類。
Observer：定義對象間的一種一對多的依賴關系,以便當一個對象的狀态發生改變時,全部依賴于它的對象都得到通知并自己主動重新整理。
Memento：在不破壞封裝性的前提下，捕獲一個對象的内部狀态，并在該對象之外儲存這個狀态。這樣以後就可将該對象恢複到儲存的狀态。
Mediator：用一個中介對象來封裝一系列的對象互動。中介者使各對象不須要顯式地互相引用。進而使其耦合松散。而且能夠獨立地改變它們之間的互動。
Command：将一個請求封裝為一個對象，進而使你可用不同的請求對客戶進行參數化。對請求排隊或記錄請求日志，以及支援可取消的操作。
Visitor：表示一個作用于某對象結構中的各元素的操作。它使你能夠在不改變各元素的類的前提下定義作用于這些元素的新操作。
Chain of Responsibility：為解除請求的發送者和接收者之間耦合。而使多個對象都有機會處理這個請求。将這些對象連成一條鍊。并沿着這條鍊傳遞該請求。直到有一個對象處理它。
Iterator：提供一種方法順序訪問一個聚合對象中各個元素, 而又不需暴露該對象的内部表示。
Interpreter：給定一個語言, 定義它的文法的一種表示，并定義一個解釋器, 該解釋器使用該表示來解釋語言中的句子。
State：(1)、意圖：同意一個對象在其内部狀态改變時改變它的行為。對象看起來似乎改動了它的類。
(2)、适用性：A、一個對象的行為取決于它的狀态。而且它必須在執行時刻依據狀态改變它的行為。
B、一個操作中含有龐大的多分支的條件語句，且這些分支依賴于該對象的狀态。
這個狀态通經常使用一個或多個枚舉常量表示。
通常，有多個操作包含這一相同的條件結構。State模式将每個條件分支放入一個獨立的類中。這使得你能夠依據對象自身的情況将對象的狀态作為一個對象，這一對象能夠不依賴于其它對象而獨立變化。
(3)、相關模式：A、Flyweight模式解釋了何時以及怎樣共享狀态對象。B、狀态對象一般是Singleton。
(4)、當一個對象的行為取決于它的狀态，而且它必須在執行時刻依據狀态改變它的行為時，可考慮用到狀态模式。
(5)、在State模式中。将狀态邏輯和動作實作進行分離。當一個操作中要維護大量的case分支語句。而且這些分支依賴于對象的狀态。
State模式将每個分支都封裝到獨立的類中。State模式和Strategy模式有非常大程度上的類似：它們都有一個Context類，都是通過托付(組合)給一個具有多個派生類的多态基類實作Context的算法邏輯。
兩者最大的差別就是State模式重派生類持有指向Context對象的引用，并通過這個引用調用Context中的方法。可是Strategy模式中就沒有這樣的情況。是以能夠說一個State執行個體相同是Strategy模式的一個執行個體，反之卻不成立。
實際上State模式和Strategy模式的差別還在于它們所關注的點不盡相同：State模式主要是要适應對象對于狀态改變時的不同處理政策的實作，而Strategy則主要是詳細算法和實作接口的解耦(coupling)，Strategy模式中并沒有狀态的概念(盡管非常多時候能夠被看作是狀态的概念)，而且更加不關心狀态的改變了。State模式非常好地實作了對象的狀态邏輯和動作實作的分離，狀态邏輯分布在State的派生類中實作，而動作實作則能夠放在Context類中實作(這也是為什麼State派生類須要擁有一個指向Context的指針)。這使得兩者的變化互相獨立，改變State的狀态邏輯能夠非常easy複用Context的動作，也能夠在不影響State派生類的前提下建立Context的子類來更改或替換動作實作。
State模式問題主要是邏輯分散化，狀态邏輯分布到了非常大的State的子類中。非常難看到整個的狀态邏輯圖，這也帶來了代碼的維護問題。
示範樣例代碼1：
#include <iostream>
using namespace std;
class Work;
class ForenoonState;
class NoonState;
class State
{
public:
virtual void WriteProgram(Work* w) = 0;
};
class Work
{
private:
State* current;
public:
double hour;
public:
Work();
void SetState(State* temp)
{
current = temp;
}
void Writeprogram()
{
current->WriteProgram(this);
}
};
class NoonState : public State
{
public:
virtual void WriteProgram(Work* w)
{
cout<<"execute"<<endl;
if ((w->hour) < 13)
cout<<"還不錯啦"<<endl;
else
cout<<"不行了，還是睡覺吧"<<endl;
}
};
class ForenoonState : public State
{
public:
virtual void WriteProgram(Work* w)
{
if ((w->hour) < 12)
cout<<"如今的精神無敵好"<<endl;
else {
w->SetState(new NoonState());
w->Writeprogram();//注意加上這句
}
}
};
Work::Work()
{
current = new ForenoonState();
}
//client
int main()
{
Work* mywork = new Work();
mywork->hour = 9;
mywork->Writeprogram();
mywork->hour = 14;
mywork->Writeprogram();
/*result
如今的精神無敵好
execute
不行了。還是睡覺吧
*/
return 0;
} 示範樣例代碼2：
State.h:
#ifndef _STATE_H_
#define _STATE_H_
class Context;//前置聲明
class State
{
public:
State();
virtual ~State();
virtual void OperationInterface(Context*) = 0;
virtual void OperationChangeState(Context*) = 0;
protected:
bool ChangeState(Context* con, State* st);
};
class ConcreteStateA : public State
{
public:
ConcreteStateA();
virtual ~ConcreteStateA();
virtual void OperationInterface(Context*);
virtual void OperationChangeState(Context*);
protected:
private:
};
class ConcreteStateB : public State
{
public:
ConcreteStateB();
virtual ~ConcreteStateB();
virtual void OperationInterface(Context*);
virtual void OperationChangeState(Context*);
protected:
private:
};
#endif//~_STATE_H_ State.cpp:
#include "State.h"
#include "Context.h"
#include <iostream>
using namespace std;
State::State()
{
}
State::~State()
{
}
void State::OperationInterface(Context* con)
{
cout<<"State:: ..."<<endl;
}
bool State::ChangeState(Context* con, State* st)
{
con->ChangeState(st);
return true;
}
void State::OperationChangeState(Context* con)
{
}
ConcreteStateA::ConcreteStateA()
{
}
ConcreteStateA::~ConcreteStateA()
{
}
void ConcreteStateA::OperationInterface(Context* con)
{
cout<<"ConcreteStateA::OperationInterface ..."<<endl;
}
void ConcreteStateA::OperationChangeState(Context* con)
{
OperationInterface(con);
this->ChangeState(con, new ConcreteStateB());
}
ConcreteStateB::ConcreteStateB()
{
}
ConcreteStateB::~ConcreteStateB()
{
}
void ConcreteStateB::OperationInterface(Context* con)
{
cout<<"ConcreteStateB::OperationInterface ..."<<endl;
}
void ConcreteStateB::OperationChangeState(Context* con)
{
OperationInterface(con);
this->ChangeState(con, new ConcreteStateA());
} Context.h:
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class State;
class Context
{
public:
Context();
Context(State* state);
~Context();
void OperationInterface();
void OperationChangeState();
protected:
private:
friend class State;//表明在State類中能夠訪問Context類的private字段
bool ChangeState(State* state);
private:
State* _state;
};
#endif//~_CONTEXT_H_ Context.cpp:
#include "Context.h"
#include "State.h"
Context::Context()
{
}
Context::Context(State* state)
{
this->_state = state;
}
Context::~Context()
{
delete _state;
}
void Context::OperationInterface()
{
_state->OperationInterface(this);
}
bool Context::ChangeState(State* state)
{
//_state->ChangeState(this, state);
this->_state = state;
return true;
}
void Context::OperationChangeState()
{
_state->OperationChangeState(this);
} main.cpp:
#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
int main()
{
State* st = new ConcreteStateA();
Context* con = new Context(st);
con->OperationChangeState();
con->OperationChangeState();
con->OperationChangeState();
if (con != NULL)
delete con;
if (st != NULL)
st = NULL;
/*result
ConcreteStateA::OperationInterface ...
ConcreteStateB::OperationInterface ...
ConcreteStateA::OperationInterface ...
*/
return 0;
}
狀态模式結構圖：
參考文獻：
1、《大話設計模式C++》