C++設計模式類庫 Loki介紹與用法

C++設計模式類庫 Loki介紹與用法 Loki是由Andrei編寫的一個與《Modern C++ Design》（C++設計新思惟）一書配套發行的C++代碼庫。 它不只把C++模板的功能發揮到了極致，並且把相似設計模式這樣思想層面的東西經過庫來提供。 本篇文章介紹如何利用Loki來輕鬆地實現一些設計模式。 因爲Loki使用了大量牛X到爆的模板技巧，對編譯器的要求是很苛刻的，官方兼容列表裏只列出了VC7.1以上版本及GCC3.4以上版本。若是你象我同樣喜歡用C++Builder6或VC6，能夠去下載《Modern C++ Design》配套源碼，那裏面的Loki提供了對其它不兼容編譯器的移植代碼，只是版本低了一點，有些接口有些差異。 最後，BTW，《Modern C++ Design》確實是一本好書，在這裏也順便推薦一下^_^ Loki的下載地址是http://sourceforge.net/projects/loki-lib/，目前最新版本是Loki 0.1.7，後面的代碼都使用這個版本做爲測試標準。 編譯 Loki庫提供了N多種編譯途經，你能夠直接打開項目文件（VC、Code::Block、Cpp-Dev等IDE）編譯，也能夠用傳統的makefile來make，還能夠直接用批處理文件編譯。象我這種被IDE慣壞的人，通常都是直接把src目錄裏的代碼加入到項目中了事。 Singleton模式(單件模式) Singleton模式確保一個類在系統中只有一個實例。好比一個窗口系統中只能有一個鼠標對象，只有一個屏幕對象，一個剪切板對象...。咱們能夠用一個全局變量來作這些工做，但它不能防止實例化多個對象。一個更好的辦法是讓類自身保存它的惟一實例，而且不容許建立其它實例，這就是Singleton模式。 Loki庫的SingletonHolder類提供了對Singleton模式的支持 頭文件 #include <loki/Singleton.h> 類型定義 template< typename T, template< class > class CreationPolicy = CreateUsingNew, template< class > class LifetimePolicy = DefaultLifetime, template< class, class > class ThreadingModel = ::Loki::SingleThreaded, class MutexPolicy = ::Loki::Mutex> class Loki::SingletonHolder; Loki的類大部分都是基於策略編程的，其中最主要的是CreationPolicy，它決定了怎樣生成一個類實例，可選的有： template<template<class> class Alloc> struct CreateUsing; 在分配器分配的內存中生成實例，如 template <class T> struct CreateStatic 生成靜態實例 template <class T> struct CreateUsingMalloc 使用malloc申請內存並在其中生成實例 template <class T> struct CreateUsingNew 使用new生成實例（默認） 示例代碼 class MyClass{ public: // 有默認構造 MyClass(){;} // 顯示本身所在的內存地址，用以區分是不是同一個對象 void ShowPtr() { std::cout << this << std::endl; } }; // 定義Singleton的MyClass typedef Loki::SingletonHolder<MyClass> MyClassSingleton; int _tmain(int argc, _TCHAR* argv[]) { // 經過Instance()靜態方法取得MyClass實例 MyClass& v = MyClassSingleton::Instance(); v.ShowPtr(); // MyClassSingleton::Instance()老是返回同一個MyClass實例 MyClassSingleton::Instance().ShowPtr(); return 0; } Loki::SingletonHolder默認的CreationPolicy策略要求類必須有默認構造，如MyClass這樣。若是須要包裝沒有默認構造的類的話，咱們就得自定義一個CreationPolicy策略，好在CreationPolicy策略比較簡單，先看看Loki中默認的CreateUsingNew吧: template <class T> struct CreateUsingNew { static T* Create() { return new T; } static void Destroy(T* p) { delete p; } }; 呵呵，簡單吧，只是簡單的Create和Destroy而已。 咱們只要修改Create()靜態方法，new一個本身的對象就能夠了，固然隨便多少構造參數均可以在這裏寫上去啦。另外，若有必要，也能夠作一些其它初始工做哦。 class MyClass2{ public: // 構造裏要求兩個整數 MyClass2(int,int){;} void ShowPtr() { std::cout << this << std::endl; } }; // 咱們本身的CreationPolicy策略 template<class T> class CreateMyClass2UsingNew: public Loki::CreateUsingNew<T> { public: static T* Create() { return new T(0,0); } }; // 定義使用CreateMyClass2UsingNew策略的Singleton類 typedef Loki::SingletonHolder<MyClass2, CreateMyClass2UsingNew> MyClass2Singleton; // 使用之 int _tmain(int argc, _TCHAR* argv[]) { MyClass2Singleton::Instance().ShowPtr(); MyClass2Singleton::Instance().ShowPtr(); return 0; }

usidc5 2011-01-18 16:48 對象工廠 Object Factory 又名簡單工廠模式，貌似不屬於設計模式範疇。它的做用是把對象的建立工做集中起來，並使建立工做與其它部分解耦。好比下面這個函數也可看成簡單工廠： CWinBase* Create(string s) { if(s == "Edit") return new CEdit; else if(s == "Button") return new CButton; ... } Loki庫的Factory類提供了對簡單工廠模式的支持。 頭文件 #include 類型 template< class AbstractProduct, // 「產品」基類型 typename IdentifierType, // 用什麼區分各產品 typename CreatorParmTList = NullType, // 生成器參數 template< typename, class > class FactoryErrorPolicy = DefaultFactoryError> class Loki::Factory; 成員方法 bool Register(const IdentifierType& id, ProductCreator creator); 以id做爲識別碼註冊生成器。函數、對象方法或仿函數均可以做爲生成器。 bool Unregister(const IdentifierType& id); 取消註冊 std::vector RegisteredIds(); 取得已註冊的全部識別碼 AbstractProduct* CreateObject(const IdentifierType& id); AbstractProduct* CreateObject(const IdentifierType& id, Parm1 p1); AbstractProduct* CreateObject(const IdentifierType& id, Parm1 p1, Parm2 p2); ... 按識別碼id生成對象(調用對應的生成器) 示例代碼 #include #include #include #include // 窗體基類 struct IWidget{ virtual void printName() = 0; virtual ~IWidget(){;} }; // 定義窗體工廠，使用string區分各對象類型 typedef Loki::Factory widget_factory_t;</iwidget, std::string> // 按鈕窗體 struct CButton : IWidget{ void printName() { std::cout << "CButton" << std::endl; } }; // 編輯框窗體 struct CEdit : IWidget{ void printName() { std::cout << "CEdit" << std::endl; } }; // 列表框窗體 struct CListBox : IWidget{ void printName() { std::cout << "CListBox" << std::endl; } }; int _tmain(int argc, _TCHAR* argv[]) { // 工廠實例 widget_factory_t wf; // 註冊各類窗體的生成器，這裏偷懶用了CreateUsingNew做爲生成器 wf.Register("Edit", Loki::CreateUsingNew::Create ); wf.Register("Button", Loki::CreateUsingNew::Create ); wf.Register("ListBox", Loki::CreateUsingNew::Create ); // 測試，使用工廠生成窗體 { IWidget* pWid = wf.CreateObject("Edit"); pWid->printName(); delete pWid; } { IWidget* pWid = wf.CreateObject("ListBox"); pWid->printName(); delete pWid; } return 0; } 不少時候，工廠每每只須要一個實例，咱們可使用前面說過的SingletonHolder把widget_factory_t弄成Singleton模式。 上面生成CButton之類的窗體時使用的是默認構造，因此我偷懶沒寫各個類的生成器，直接用了Loki::CreateUsingNew。 若是你的類有構造參數的話，那麼就得在Loki::Factory模板參數中指出參數類型，而且自定義生成器，就象這樣： #include #include #include // 窗體基類 struct IWidget{ virtual void printName() = 0; virtual ~IWidget(){;} }; // 定義窗體工廠，這裏用Loki::Seq指定參數類型 typedef Loki::Factory< IWidget, std::string, Loki::Seq<int, char> > widget_factory_t; // 單件模式，注意Lifetime策略要選擇Loki::LongevityLifetime::DieAsSmallObjectChild，不然... typedef Loki::SingletonHolder<widget_factory_t, loki::createusingnew,< span=""></widget_factory_t, loki::createusingnew,<> Loki::LongevityLifetime::DieAsSmallObjectChild> Singleton_Fac; // 按鈕窗體 struct CButton : IWidget{ void printName() { std::cout << "CButton:" << m_txt << std::endl; } CButton(std::string txt, int, char) //多個構造參數 :m_txt(txt){} std::string m_txt; }; // 編輯框窗體 struct CEdit : IWidget{ void printName() { std::cout << "CEdit:" << m_txt << std::endl; } CEdit(std::string txt, int, char) //多個構造參數 :m_txt(txt){} std::string m_txt; }; // 列表框窗體 struct CListBox : IWidget{ void printName() { std::cout << "CListBox:" << m_txt << std::endl; } CListBox(std::string txt, int, char) //多個構造參數 :m_txt(txt){} std::string m_txt; }; // 自定義的窗體構造器，用模板只是爲了方便點^_^ template<class T> struct CreateT { T * operator()(std::string txt, int p1, char p2) const { return new T(txt, p1, p2); } }; int _tmain(int argc, _TCHAR* argv[]) { // 工廠實例 widget_factory_t& wf = Singleton_Fac::Instance(); // 註冊各類窗體的生成器，用咱們的生成器 wf.Register("Edit", CreateT() ); wf.Register("Button", CreateT() ); wf.Register("ListBox", CreateT() ); // 測試，使用工廠生成窗體 { IWidget* pWid = wf.CreateObject("Edit", "Hello", 0, ' '); pWid->printName(); delete pWid; } { IWidget* pWid = wf.CreateObject("ListBox", "World", 0, ' '); pWid->printName(); delete pWid; } return 0; } Loki::Seq是一個相似於TypeList的東東，能夠存放一系列的類型。另外用SingletonHolder包裝Factory時，必定要用Loki::LongevityLifetime::DieAsSmallObjectChild做爲SingletonHolder的lifttime策略（Loki使用說明上說的，因爲Factory使用了Loki內部的內存管理器SmallObject）。

usidc5 2011-01-18 16:49 Abstract Factory模式（抽象工廠） 抽象工廠提供了一個建立一系列相關或相互依賴對象的接口，而無需指定具體的類。 好比要編寫一個可換膚的用戶界面，那麼咱們生成的每一個窗體都應該遵循統一的風格，不該該在一個界面裏同時出現Mac風格和Win風格的按鈕。爲了便於控制，咱們能夠這樣寫代碼： struct IWidgetFactory{ virtual IButton* CreateButton() = 0; virtual IEdit* CreateEdit() = 0; virtual IListBox* CreateListBox() = 0; }; struct CWindowsFactory : IWidgetFactory{ virtual IButton* CreateButton(){生成Win風格按鈕;} virtual IEdit* CreateEdit(){生成Win風格編輯框;} virtual IListBox* CreateListBox(){生成Win風格列表框;} }; struct CMacFactory : IWidgetFactory{ virtual IButton* CreateButton(){生成Mac風格按鈕;} virtual IEdit* CreateEdit(){生成Mac風格編輯框;} virtual IListBox* CreateListBox(){生成Mac風格列表框;} }; 這樣，在程序中咱們要用執有IWidgetFactory指針，在必要時實例化某個具體風格的工廠類，最後全部的窗體都由這個IWidgetFactory指針來生成便可。這就是Abstract Factory模式。Loki庫的AbstractFactory和ConcreteFactory提供了對Abstract Factory模式的支持。 頭文件 #include 類型 template < class TList, template <class> class Unit = AbstractFactoryUnit > class AbstractFactory; AbstractFactory模板類是一個虛類，它根據TList中的類型提供一組Create<>()方法。 模板參數TList是一個Typelist，輸入全部工廠可生產的產品基類，如前面的IButton,IEdit,IListBox。 模板參數Unit依據TList中的全部類型產生對應的Create<>()虛函數，通常直接用默認的AbstractFactoryUnit就能夠了。 template < class AbstractFact, template <class, class> class Creator = OpNewFactoryUnit, class TList = typename AbstractFact::ProductList > class ConcreteFactory; ConcreteFactory實現了AbstractFactory中的Create<>()方法 模板參數AbstractFact就是對應的AbstractFactory類 模板參數Creator是產品實例的生成策略，可選的有OpNewFactoryUnit和PrototypeFactoryUnit。 OpNewFactoryUnit使用new生成新的產品實例； PrototypeFactoryUnit使用已有產品(原型)的Clone()方法生成新的實例，這也意味着要使用PrototypeFactoryUnit咱們的產品基類必需要有T *Clone()成員方法。 TList提供一組具體的產品類型，若是Creator策略是PrototypeFactoryUnit，能夠不提供。 演示代碼 #include #include #include // 產品基類 struct IButton{ virtual void click() = 0; }; struct IEdit{ virtual void edit() = 0; }; struct IListBox{ virtual void scroll() = 0; }; // 抽象工廠 typedef Loki::AbstractFactory< LOKI_TYPELIST_3(IButton, IEdit, IListBox) //也能夠用Loki::Seq< IButton, IEdit, IListBox >::Type > IWidgetFactory; // 具體產品-Win struct CWinBtn : IButton{ virtual void click(){ std::cout<< "CWinBtn Clicked" << std::endl; } }; struct CWinEdit : IEdit{ virtual void edit(){ std::cout<< "CWinEdit Editing" << std::endl; } }; struct CWinLB : IListBox{ virtual void scroll(){ std::cout<< "CWinLB Scrolling" << std::endl; } }; // 具體產品-Mac struct CMacBtn : IButton{ virtual void click(){ std::cout<< "CMacBtn Clicked" << std::endl; } }; struct CMacEdit : IEdit{ virtual void edit(){ std::cout<< "CMacEdit Editing" << std::endl; } }; struct CMacLB : IListBox{ virtual void scroll(){ std::cout<< "CMacLB Scrolling" << std::endl; } }; // 具體工廠 typedef Loki::ConcreteFactory< IWidgetFactory, Loki::OpNewFactoryUnit, LOKI_TYPELIST_3(CWinBtn, CWinEdit, CWinLB) > CWindowsFactory; typedef Loki::ConcreteFactory< IWidgetFactory, Loki::OpNewFactoryUnit, LOKI_TYPELIST_3(CMacBtn, CMacEdit, CMacLB) > CMacFactory; // 使用工廠生成的產品 void UsingWidget(IWidgetFactory *pFac) { IEdit* pEdt = pFac->Create(); IButton* pBtn = pFac->Create(); IListBox* pLB = pFac->Create(); pEdt->edit(); pBtn->click(); pLB->scroll(); delete pEdt; delete pBtn; delete pLB; } int _tmain(int argc, _TCHAR* argv[]) { // 使用Win風格 { CWindowsFactory winfac; UsingWidget(&winfac); } // 使用Mac風格 { CMacFactory macfac; UsingWidget(&macfac); } return 0; }

usidc5 2011-01-18 16:49 Visitor 模式(訪問者模式) 訪問者模式把對某對象結構中的各元素的相關操做集中到一塊兒，能夠方便地在不改變無素類的前提下添加新的操做。 假設一個XML類，咱們可能要打印、保存、轉換這個XML數據。實際上這些操做都須要遍歷節點，不一樣的只是操做的方式，咱們能夠這樣寫代碼： struct IVisitor; struct TTextNode{ virtual void accept(IVisitor *visitor){ visitor->visit(this); } }; struct TCDataNode{ virtual void accept(IVisitor *visitor){ visitor->visit(this); } }; struct TElementNode{ virtual void accept(IVisitor *visitor){ visitor->visit(this); } }; struct IVisitor{ virtual void visit(TTextNode*) = 0; virtual void visit(TCDataNode*) = 0; virtual void visit(TElementNode*) = 0; }; struct CSaveVisitor{ virtual void visit(TTextNode*){ 保存文本內容 } virtual void visit(TCDataNode*){ 保存[[CData內容]] } virtual void visit(TElementNode*){ 保存<標籤> 全部子節點.accept(this) } }; struct CPrintVisitor{ ... }; 固然，這種模式的問題是可能會破壞一些封裝性。咱們這裏不討論Visitor模式的優劣，先看看Loki是怎麼實現這個模式的吧 頭文件 #include 類型 template < typename R = void, template <typename, class> class CatchAll = DefaultCatchAll, bool ConstVisitable = false > class BaseVisitable; 可訪問類型的基類，若是要讓元素能被訪問，要必須繼承自BaseVisitable。 模板參數R是Accept()方法的返回值。 模板參數CatchAll表示某元素沒有對應的訪問方法時的反應，默認的DefaultCatchAll是什麼也不作。 模板參數ConstVisitable表示Accept()方法是不是const方法。 class BaseVisitor; 全部訪問者的基類 template < class T, typename R = void, bool ConstVisit = false> class Visitor; 訪問者實現模板 模板參數T是一個Typelist，表示訪問者能接受的全部元素類型 模板參數R是Visit()方法的返回值 模板參數ConstVisit表示Visit()方法是不是const方法。 示例代碼 #include #include #include #include #include // XML元素 struct TTextNode : Loki::BaseVisitable<>{ LOKI_DEFINE_VISITABLE(); TTextNode(std::string text) :m_text(text){} std::string m_text; }; struct TCDataNode : Loki::BaseVisitable<>{ LOKI_DEFINE_VISITABLE(); TCDataNode(std::string text) :m_cdata(text){} std::string m_cdata; }; struct TElementNode : Loki::BaseVisitable<>{ LOKI_DEFINE_VISITABLE(); std::string m_name; TElementNode(std::string text) :m_name(text){} typedef Loki::BaseVisitable<> visitable_t; //這裏用了Loki::SmartPtr，這是一個智能指針類型 typedef Loki::SmartPtr< Loki::BaseVisitable<> > ptr_t; std::vector< ptr_t > m_childs; }; // 訪問者，必須繼承自BaseVisitor class CPrintVisitor : public Loki::BaseVisitor, public Loki::Visitor { public: void Visit(TTextNode& n){std::cout << n.m_text;} void Visit(TCDataNode& n){std::cout << " << n.m_cdata << "]]>";} void Visit(TElementNode& n){ std::cout<<std::endl;< span=""> std::cout<< '<' << n.m_name << '>' << std::endl; for(size_t idx=0, len=n.m_childs.size(); idx<len; idx++ )< span=""></len; idx++ )<> { n.m_childs[idx]->Accept(*this); } std::cout<< std::endl << " << n.m_name << '>' << std::endl; } }; int main() { // 構建XML結構 TElementNode root("root"); TElementNode *child1 = new TElementNode("child1"); child1->m_childs.push_back(new TTextNode("hello")); TElementNode *child2 = new TElementNode("child2"); child2->m_childs.push_back(new TCDataNode("world >_<")); root.m_childs.push_back( child1 ); root.m_childs.push_back( child2 ); // 用CPrintVisitor訪問XML全部元素 CPrintVisitor visitor; root.Accept(visitor); } 輸出結果 hello _<]]>

usidc5 2011-01-18 16:51 大牛Andrei Alexandrescu的《Modern C++ Design》討論的是C++語言的最前沿研究：generative programming。本書中譯版估計得要半年之後才能出來，因此只能靠其所附源碼來窺測generative programming了。 　　目前，我剛將源碼讀解了約一半，等所有讀完，我會將個人讀解註釋放出來的。如今，現談一下個人感想。 　　 先扯得遠一點。C++有兩個巨大優勢：和C兼容，自由；有兩個巨大缺點：和C兼容，複雜。C++極其複雜，很難掌握，而這正是「自由」的代價。C++語言是個多編程風格的語言，它同時支持過程化、基於對象、面向對象、泛型、生成性這5種編程思想，具備極其強大的表達能力，能夠方便地將各類設計轉化爲實現。 　　generic Programming的思想精髓是基於接口編程（相對於OOP，連多態所需的基類都不要了），它的技術出發點是選擇子，核心技術是：類型推導、類型萃取、特化/偏特化，其成果是STL庫：一組通用容器和一組操做於通用容器上的通用算法。 　　generative programming的思想精髓是基於策略編程（編譯器根據策略自動生成所需代碼，因爲具備更高的抽象性，因此代碼複用度也更高），在Loki庫的實現中，目前只使用了遞歸策略，它的技術出發點是Typelist，核心技術是：類型推導、類型萃取、特化/偏特化、多重繼承、類型間去耦合，其成果是Loki庫：對設計模式的封裝。 　　Typelist是一種對類型自己進行存儲和管理的技巧，它的源碼已經貼過了，我也做了註解，此處再也不談論。 　　這是多重繼承在COM以後的又一大型運用。多重繼承極易發生菱型缺陷，因此Loki庫使用了類型間去耦合技術來避免： 　　 template <typename T> 　　 struct Type2Type 　　 { 　　 typedef T OriginalType; 　　 }; 　　通過這樣一層轉換後，原類型T間的各類轉換關係（尤爲是繼承/派生關係）已不復存在，菱型缺陷不會再發生了。 　　Loki庫的具體實現至關講究技巧，設計它很是困難（難度遠大於STL庫，和Boost庫有得一拼啊）。但使用它卻很是容易，並且便利顯著。因爲Loki庫提供了對設計模式的封裝，因此極大量地豐富了C++語言的表達能力，使的你的設計更容易地轉化爲實現。 　　目前，Loki庫只提供了對廠模式和visitor模式的封裝，它還處於發展初期。 來源： http://blog.csdn.net/chollima/article/details/8158580

來自爲知筆記(Wiz)