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模式的支持

头文件

类型定义

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生成实例（默认）

示例代码

Loki::SingletonHolder默认的CreationPolicy策略要求类必须有默认构造，如MyClass这样。如果需要包装没有默认构造的类的话，我们就得自定义一个CreationPolicy策略，好在CreationPolicy策略比较简单，先看看Loki中默认的CreateUsingNew吧:

呵呵，简单吧，只是简单的Create和Destroy而已。

我们只要修改Create()静态方法，new一个自己的对象就可以了，当然随便多少构造参数都可以在这里写上去啦。另外，如有必要，也可以做一些其它初始工作哦。

1. CWinBase* Create(string s)
2. {
3. if(s == "Edit")
4. return new CEdit;
5. else if(s == "Button")
6. return new CButton;
7. ...
8. }

1. #include

1. template<
2. class AbstractProduct, // “产品”基类型
3. typename IdentifierType, // 用什么区分各产品
4. typename CreatorParmTList = NullType, // 生成器参数
5. template< typename, class > class FactoryErrorPolicy = DefaultFactoryError>
6. class Loki::Factory;

1. #include
2. #include
3. #include
4. #include
5. // 窗体基类
6. struct IWidget{
7. virtual void printName() = 0;
8. virtual ~IWidget(){;}
9. };
10. // 定义窗体工厂，使用string区分各对象类型
11. typedef Loki::Factory widget_factory_t;</iwidget, std::string>
12. // 按钮窗体
13. struct CButton : IWidget{
14. void printName()
15. {
16. std::cout << "CButton" << std::endl;
17. }
18. };
19. // 编辑框窗体
20. struct CEdit : IWidget{
21. void printName()
22. {
23. std::cout << "CEdit" << std::endl;
24. }
25. };
26. // 列表框窗体
27. struct CListBox : IWidget{
28. void printName()
29. {
30. std::cout << "CListBox" << std::endl;
31. }
32. };
33. int _tmain(int argc, _TCHAR* argv[])
34. {
35. // 工厂实例
36. widget_factory_t wf;
37. // 注册各种窗体的生成器，这里偷懒用了CreateUsingNew作为生成器
38. wf.Register("Edit", Loki::CreateUsingNew::Create );
39. wf.Register("Button", Loki::CreateUsingNew::Create );
40. wf.Register("ListBox", Loki::CreateUsingNew::Create );
41. // 测试，使用工厂生成窗体
42. {
43. IWidget* pWid = wf.CreateObject("Edit");
44. pWid->printName();
45. delete pWid;
46. }
47. {
48. IWidget* pWid = wf.CreateObject("ListBox");
49. pWid->printName();
50. delete pWid;
51. }
52. return 0;
53. }

1. #include
2. #include
3. #include
4. // 窗体基类
5. struct IWidget{
6. virtual void printName() = 0;
7. virtual ~IWidget(){;}
8. };
9. // 定义窗体工厂，这里用Loki::Seq指定参数类型
10. typedef Loki::Factory<
11. IWidget,
12. std::string,
13. Loki::Seq<int, char>
14. > widget_factory_t;
15. // 单件模式，注意Lifetime策略要选择Loki::LongevityLifetime::DieAsSmallObjectChild，否则...
16. typedef Loki::SingletonHolder<widget_factory_t, loki::createusingnew,< span=""></widget_factory_t, loki::createusingnew,<>
17. Loki::LongevityLifetime::DieAsSmallObjectChild> Singleton_Fac;
18. // 按钮窗体
19. struct CButton : IWidget{
20. void printName()
21. {
22. std::cout << "CButton:" << m_txt << std::endl;
23. }
24. CButton(std::string txt, int, char) //多个构造参数
25. :m_txt(txt){}
26. std::string m_txt;
27. };
28. // 编辑框窗体
29. struct CEdit : IWidget{
30. void printName()
31. {
32. std::cout << "CEdit:" << m_txt << std::endl;
33. }
34. CEdit(std::string txt, int, char) //多个构造参数
35. :m_txt(txt){}
36. std::string m_txt;
37. };
38. // 列表框窗体
39. struct CListBox : IWidget{
40. void printName()
41. {
42. std::cout << "CListBox:" << m_txt << std::endl;
43. }
44. CListBox(std::string txt, int, char) //多个构造参数
45. :m_txt(txt){}
46. std::string m_txt;
47. };
48. // 自定义的窗体构造器，用模板只是为了方便点^_^
49. template<class T> struct CreateT
50. {
51. T * operator()(std::string txt, int p1, char p2) const
52. {
53. return new T(txt, p1, p2);
54. }
55. };
56. int _tmain(int argc, _TCHAR* argv[])
57. {
58. // 工厂实例
59. widget_factory_t& wf = Singleton_Fac::Instance();
60. // 注册各种窗体的生成器，用我们的生成器
61. wf.Register("Edit", CreateT() );
62. wf.Register("Button", CreateT() );
63. wf.Register("ListBox", CreateT() );
64. // 测试，使用工厂生成窗体
65. {
66. IWidget* pWid = wf.CreateObject("Edit", "Hello", 0, ' ');
67. pWid->printName();
68. delete pWid;
69. }
70. {
71. IWidget* pWid = wf.CreateObject("ListBox", "World", 0, ' ');
72. pWid->printName();
73. delete pWid;
74. }
75. return 0;
76. }

1. struct IWidgetFactory{
2. virtual IButton* CreateButton() = 0;
3. virtual IEdit* CreateEdit() = 0;
4. virtual IListBox* CreateListBox() = 0;
5. };
6. struct CWindowsFactory : IWidgetFactory{
7. virtual IButton* CreateButton(){生成Win风格按钮;}
8. virtual IEdit* CreateEdit(){生成Win风格编辑框;}
9. virtual IListBox* CreateListBox(){生成Win风格列表框;}
10. };
11. struct CMacFactory : IWidgetFactory{
12. virtual IButton* CreateButton(){生成Mac风格按钮;}
13. virtual IEdit* CreateEdit(){生成Mac风格编辑框;}
14. virtual IListBox* CreateListBox(){生成Mac风格列表框;}
15. };

1. #include

template
<class TList,template <class>class Unit = AbstractFactoryUnit
>
class AbstractFactory;

template
<class AbstractFact,template <class, class>class Creator = OpNewFactoryUnit,class TList = typename AbstractFact::ProductList
>
class ConcreteFactory;

1. #include
2. #include
3. #include
4. // 产品基类
5. struct IButton{
6. virtual void click() = 0;
7. };
8. struct IEdit{
9. virtual void edit() = 0;
10. };
11. struct IListBox{
12. virtual void scroll() = 0;
13. };
14. // 抽象工厂
15. typedef Loki::AbstractFactory<
16. LOKI_TYPELIST_3(IButton, IEdit, IListBox) //也可以用Loki::Seq< IButton, IEdit, IListBox >::Type
17. > IWidgetFactory;
18. // 具体产品-Win
19. struct CWinBtn : IButton{
20. virtual void click(){
21. std::cout<< "CWinBtn Clicked" << std::endl;
22. }
23. };
24. struct CWinEdit : IEdit{
25. virtual void edit(){
26. std::cout<< "CWinEdit Editing" << std::endl;
27. }
28. };
29. struct CWinLB : IListBox{
30. virtual void scroll(){
31. std::cout<< "CWinLB Scrolling" << std::endl;
32. }
33. };
34. // 具体产品-Mac
35. struct CMacBtn : IButton{
36. virtual void click(){
37. std::cout<< "CMacBtn Clicked" << std::endl;
38. }
39. };
40. struct CMacEdit : IEdit{
41. virtual void edit(){
42. std::cout<< "CMacEdit Editing" << std::endl;
43. }
44. };
45. struct CMacLB : IListBox{
46. virtual void scroll(){
47. std::cout<< "CMacLB Scrolling" << std::endl;
48. }
49. };
50. // 具体工厂
51. typedef Loki::ConcreteFactory<
52. IWidgetFactory,
53. Loki::OpNewFactoryUnit,
54. LOKI_TYPELIST_3(CWinBtn, CWinEdit, CWinLB)
55. > CWindowsFactory;
56. typedef Loki::ConcreteFactory<
57. IWidgetFactory,
58. Loki::OpNewFactoryUnit,
59. LOKI_TYPELIST_3(CMacBtn, CMacEdit, CMacLB)
60. > CMacFactory;
61. // 使用工厂生成的产品
62. void UsingWidget(IWidgetFactory *pFac)
63. {
64. IEdit* pEdt = pFac->Create();
65. IButton* pBtn = pFac->Create();
66. IListBox* pLB = pFac->Create();
67. pEdt->edit();
68. pBtn->click();
69. pLB->scroll();
70. delete pEdt;
71. delete pBtn;
72. delete pLB;
73. }
74. int _tmain(int argc, _TCHAR* argv[])
75. {
76. // 使用Win风格
77. {
78. CWindowsFactory winfac;
79. UsingWidget(&winfac);
80. }
81. // 使用Mac风格
82. {
83. CMacFactory macfac;
84. UsingWidget(&macfac);
85. }
86. return 0;
87. }

1. struct IVisitor;
2. struct TTextNode{
3. virtual void accept(IVisitor *visitor){ visitor->visit(this); }
4. };
5. struct TCDataNode{
6. virtual void accept(IVisitor *visitor){ visitor->visit(this); }
7. };
8. struct TElementNode{
9. virtual void accept(IVisitor *visitor){ visitor->visit(this); }
10. };
11. struct IVisitor{
12. virtual void visit(TTextNode*) = 0;
13. virtual void visit(TCDataNode*) = 0;
14. virtual void visit(TElementNode*) = 0;
15. };
16. struct CSaveVisitor{
17. virtual void visit(TTextNode*){ 保存文本内容 }
18. virtual void visit(TCDataNode*){ 保存[[CData内容]] }
19. virtual void visit(TElementNode*){ 保存<标签> 所有子节点.accept(this)  }
20. };
21. struct CPrintVisitor{
22. ...
23. };

1. #include

template
<typename R = void,template <typename, class> class CatchAll = DefaultCatchAll,bool ConstVisitable = false
>
class BaseVisitable;

class BaseVisitor;

template <class T,typename R = void,bool ConstVisit = false>
class Visitor;

1. #include
2. #include
3. #include
4. #include
5. #include
6. // XML元素
7. struct TTextNode : Loki::BaseVisitable<>{
8. LOKI_DEFINE_VISITABLE();
9. TTextNode(std::string text)
10. :m_text(text){}
11. std::string m_text;
12. };
13. struct TCDataNode : Loki::BaseVisitable<>{
14. LOKI_DEFINE_VISITABLE();
15. TCDataNode(std::string text)
16. :m_cdata(text){}
17. std::string m_cdata;
18. };
19. struct TElementNode : Loki::BaseVisitable<>{
20. LOKI_DEFINE_VISITABLE();
21. std::string m_name;
22. TElementNode(std::string text)
23. :m_name(text){}
24. typedef Loki::BaseVisitable<> visitable_t;
25. //这里用了Loki::SmartPtr，这是一个智能指针类型
26. typedef Loki::SmartPtr<
27. Loki::BaseVisitable<>
28. > ptr_t;
29. std::vector< ptr_t > m_childs;
30. };
31. // 访问者，必须继承自BaseVisitor
32. class CPrintVisitor :
33. public Loki::BaseVisitor,
34. public Loki::Visitor
35. {
36. public:
37. void Visit(TTextNode& n){std::cout << n.m_text;}
38. void Visit(TCDataNode& n){std::cout << " << n.m_cdata << "]]>";}
39. void Visit(TElementNode& n){
40. std::cout<<std::endl;< span="">
41. std::cout<< '<' << n.m_name << '>' << std::endl;
42. for(size_t idx=0, len=n.m_childs.size(); idx<len; idx++ )< span=""></len; idx++ )<>
43. {
44. n.m_childs[idx]->Accept(*this);
45. }
46. std::cout<< std::endl << " << n.m_name << '>' << std::endl;
47. }
48. };
49. int main()
50. {
51. // 构建XML结构
52. TElementNode root("root");
53. TElementNode *child1 = new TElementNode("child1");
54. child1->m_childs.push_back(new TTextNode("hello"));
55. TElementNode *child2 = new TElementNode("child2");
56. child2->m_childs.push_back(new TCDataNode("world >_<"));
57. root.m_childs.push_back( child1 );
58. root.m_childs.push_back( child2 );
59. // 用CPrintVisitor访问XML所有元素
60. CPrintVisitor visitor;
61. root.Accept(visitor);
62. }

hello_<]]>