一 、C语言和设计模式（继承、封装、多态）
C++有三个最重要的特点，即继承、封装、多态。我发现其实C语言也是可以面向对象的，也是可以应用设计模式的，关键就在于如何实现面向对象语言的三个重要属性。
（1）继承性
cpp\] view plaincopy
1. typedef struct _parent
2. {
3.
int data_parent;
4.
5. }Parent;
6.
7. typedef struct _Child
8. {
9.
struct _parent parent;
10.
int data_child;
11.
12. }Child;
在设计C语言继承性的时候，我们需要做的就是把基础数据放在继承的结构的首位置即可。这样，不管是数据的访问、数据的强转、数据的访问都不会有什么问题。
（2）封装性
\[cpp\] view plaincopy
1. struct _Data;
2.
3. typedef void (*process)(struct _Data* pData);
4.
5. typedef struct _Data
6. {
7.
int value;
8.
process pProcess;
9.
10. }Data;
封装性的意义在于，函数和数据是绑在一起的，数据和数据是绑在一起的。这样，我们就可以通过简单的一个结构指针访问到所有的数据，遍历所有的函数。封装性，这是类拥有的属性，当然也是数据结构体拥有的属性。
（3）多态
\[cpp\] view plaincopy
1. typedef struct _Play
2. {
3.
void* pData;
4.
void (*start_play)(struct _Play* pPlay);
5. }Play;
多态，就是说用同一的接口代码处理不同的数据。比如说，这里的Play结构就是一个通用的数据结构，我们也不清楚pData是什么数据，start_play是什么处理函数？但是，我们处理的时候只要调用pPlay-\>start_play(pPlay)就可以了。剩下来的事情我们不需要管，因为不同的接口会有不同的函数去处理，我们只要学会调用就可以了。
二、C语言和设计模式（访问者模式）
不知不觉当中，我们就到了最后一种设计模式，即访问者模式。访问者模式，听上去复杂一些。但是，这种模式用简单的一句话说，就是不同的人对不同的事物有不同的感觉。比如说吧，豆腐可以做成麻辣豆腐，也可以做成臭豆腐。可是，不同的地方的人未必都喜欢这两种豆腐。四川的朋友可能更喜欢辣豆腐，江浙的人就可能对臭豆腐更喜欢一些。那么，这种情况应该怎么用设计模式表达呢？
\[cpp\] view plaincopy
1. typedef struct _Tofu
2. {
3.
int type;
4.
void (*eat) (struct _Visitor* pVisitor, struct _Tofu* pTofu);
5. }Tofu;
6.
7. typedef struct _Visitor
8. {
9.
int region;
10.
void (*process)(struct _Tofu* pTofu, struct _Visitor* pVisitor);
11. }Visitor;
就是这样一个豆腐，eat的时候就要做不同的判断了。
\[cpp\] view plaincopy
12. void eat(struct _Visitor\* pVisitor, struct _Tofu\* pTofu)
13. {
14.
assert(NULL != pVisitor && NULL != pTofu);
15.
16.
pVisitor->process(pTofu, pVisitor);
17. }
既然eat的操作最后还是靠不同的visitor来处理了，那么下面就该定义process函数了。
\[cpp\] view plaincopy
18. void process(struct _Tofu\* pTofu, struct _Visitor\* pVisitor)
19. {
20.
assert(NULL != pTofu && NULL != pVisitor);
21.
22.
if(pTofu->type == SPICY_FOOD && pVisitor->region == WEST ||
23.
pTofu->type == STRONG_SMELL_FOOD && pVisitor->region == EAST)
24.
{
25.
printf("I like this food!\n");
26.
return;
27.
}
28.
29.
printf("I hate this food!\n");
30. }
三、C语言和设计模式（状态模式）
状态模式是协议交互中使用得比较多的模式。比如说，在不同的协议中，都会存在启动、保持、中止等基本状态。那么怎么灵活地转变这些状态就是我们需要考虑的事情。假设现在有一个state，
\[cpp\] view plaincopy
1. typedef struct _State
2. {
3.
void (*process)();
4.
struct _State* (*change_state)();
5.
6. }State;
说明一下，这里定义了两个变量，分别process函数和change_state函数。其中proces函数就是普通的数据操作，
\[cpp\] view plaincopy
7. void normal_process()
8. {
9.
printf("normal process!\n");
10. }
change_state函数本质上就是确定下一个状态是什么。
\[cpp\] view plaincopy
11. struct _State\* change_state()
12. {
13.
State* pNextState = NULL;
14.
15.
pNextState = (struct _State*)malloc(sizeof(struct _State));
16.
assert(NULL != pNextState);
17.
18.
pNextState ->process = next_process;
19.
pNextState ->change_state = next_change_state;
20.
return pNextState;
21. }
所以，在context中，应该有一个state变量，还应该有一个state变换函数。
\[cpp\] view plaincopy
22. typedef struct _Context
23. {
24.
State* pState;
25.
void (*change)(struct _Context* pContext);
26.
27. }Context;
28.
29. void context_change(struct _Context\* pContext)
30. {
31.
State* pPre;
32.
assert(NULL != pContext);
33.
34.
pPre = pContext->pState;
35.
pContext->pState = pPre->changeState();
36.
free(pPre);
37.
return;
38. }
四、 C语言和设计模式（命令模式）
命令模式的目的主要是为了把命令者和执行者分开。老规矩，举个范例吧。假设李老板是一家公司的头儿，他现在让他的秘书王小姐去送一封信。王小姐当然不会自己亲自把信送到目的地，她会把信交给邮局来完成整个投递的全过程。现在，我们就对投递者、命令、发令者分别作出定义。
首先定义post的相关数据。
\[cpp\] view plaincopy
1. typedef struct _Post
2. {
3.
void (*do)(struct _Post* pPost);
4. }Post;
Post完成了实际的投递工作，那么命令呢？
\[cpp\] view plaincopy
5. typedef struct _Command
6. {
7.
void* pData;
8.
void (*exe)(struct _Command* pCommand);
9.
10. }Command;
11.
12. void post_exe(struct _Command\* pCommand)
13. {
14.
assert(NULL != pCommand);
15.
16.
(Post*)(pCommand->pData)->do((Post*)(pCommand->pData));
17.
return;
18. }
我们看到了Post、Command的操作，那么剩下的就是boss的定义了。
\[cpp\] view plaincopy
19. typedef struct _Boss
20. {
21.
Command* pCommand;
22.
void (*call)(struct _Boss* pBoss);
23. }Boss;
24.
25. void boss_call(struct _Boss\* pBoss)
26. {
27.
assert(NULL != pBoss);
28.
29.
pBoss->pCommand->exe(pBoss->pCommand);
30.
return;
31. }
五、C语言和设计模式（解释器模式）
解释器模式虽然听上去有些费解，但是如果用示例说明一下就不难理解了。我们知道在C语言中，关于变量的定义是这样的：一个不以数字开始的由字母、数字和下划线构成的字符串。这种形式的表达式可以用状态自动机解决，当然也可以用解释器的方式解决。
\[cpp\] view plaincopy
1. typedef struct _Interpret
2. {
3.
int type;
4.
void* (*process)(void* pData, int* type, int* result);
5.
6. }Interpret;
上面的数据结构比较简单，但是很能说明问题。就拿变量来说吧，这里就可以定义成字母的解释器、数字解释器、下划线解释器三种形式。所以，我们可以进一步定义一下process的相关函数。
\[cpp\] view plaincopy
1. #define DIGITAL_TYPE 1
2. #define LETTER_TYPE 2
3. #define BOTTOM_LINE 3
4.
5. void\* digital_process(void\* pData, int\* type, int\* result)
6. {
7.
UINT8* str;
8.
assert(NULL != pData && NULL != type && NULL != result);
9.
10.
str = (UNT8*)pData;
11.
while (*str >= '0' && *str <= '9')
12.
{
13.
str ++;
14.
}
15.
16.
if(*str == '\0')
17.
{
18.
*result = TRUE;
19.
return NULL;
20.
}
21.
22.
if(*str == '_')
23.
{
24.
*result = TRUE;
25.
*type = BOTTOM_TYPE;
26.
return str;
27.
}
28.
29.
if(*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
30.
{
31.
*result = TRUE;
32.
*type = LETTER_TYPE;
33.
return str;
34.
}
35.
36.
*result = FALSE;
37.
return NULL;
38. }
39.
40. void\* letter_process(void\* pData, int\* type, int\* result)
41. {
42.
UINT8* str;
43.
assert(NULL != pData && NULL != type && NULL != result);
44.
45.
str = (UNT8*)pData;
46.
while (*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
47.
{
48.
str ++;
49.
}
50.
51.
if(*str == '\0')
52.
{
53.
*result = TRUE;
54.
return NULL;
55.
}
56.
57.
if(*str == '_')
58.
{
59.
*result = TRUE;
60.
*type = BOTTOM_TYPE;
61.
return str;
62.
}
63.
64.
if(*str >= '0' && *str <= '9')
65.
{
66.
*result = TRUE;
67.
*type = DIGITAL_TYPE;
68.
return str;
69.
}
70.
71.
*result = FALSE;
72.
return NULL;
73. }
74.
75. void\* bottom_process(void\* pData, int\* type, int\* result)
76. {
77.
UINT8* str;
78.
assert(NULL != pData && NULL != type && NULL != result);
79.
80.
str = (UNT8*)pData;
81.
while ('_' == *str )
82.
{
83.
str ++;
84.
}
85.
86.
if(*str == '\0')
87.
{
88.
*result = TRUE;
89.
return NULL;
90.
}
91.
92.
if(*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
93.
{
94.
*result = TRUE;
95.
*type = LETTER_TYPE;
96.
return str;
97.
}
98.
99.
if(*str >= '0' && *str <= '9')
100.
{
101.
*result = TRUE;
102.
*type = DIGITAL_TYPE;
103.
return str;
104.
}
105.
106.
*result = FALSE;
107.
return NULL;
108. }
六、C语言和设计模式（备忘录模式）
备忘录模式的起源来自于撤销的基本操作。有过word软件操作经验的朋友，应该基本上都使用过撤销的功能。举个例子，假设你不小心删除了好几个段落的文字，这时候你应该怎么办呢？其实要做的很简单，单击一些【撤销】就可以全部搞定了。撤销按钮给我们提供了一次反悔的机会。
既然是撤销，那么我们在进行某种动作的时候，就应该创建一个相应的撤销操作？这个撤销操作的相关定义可以是这样的。
\[cpp\] view plaincopy
1. typedef struct _Action
2. {
3.
int type;
4.
struct _Action* next;
5.
6.
void* pData;
7.
void (*process)(void* pData);
8.
9. }Action;
数据结构中定义了两个部分：撤销的数据、恢复的操作。那么这个撤销函数应该有一个创建的函数，还有一个恢复的函数。所以，作为撤销动作的管理者应该包括，
\[cpp\] view plaincopy
10. typedef struct _Organizer
11. {
12.
int number;
13.
Action* pActionHead;
14.
15.
Action* (*create)();
16.
void (*restore)(struct _Organizer* pOrganizer);
17. }Organizer;
既然数据在创建和修改的过程中都会有相应的恢复操作，那么要是真正恢复原来的数据也就变得非常简单了。
\[cpp\] view plaincopy
18. void restore(struct _Organizer\* pOrganizer)
19. {
20.
Action* pHead;
21.
assert(NULL != pOrganizer);
22.
23.
pHead = pOrganizer->pActionHead;
24.
pHead->process(pHead->pData);
25.
pOrganizer->pActionHead = pHead->next;
26.
pOrganizer->number --;
27.
free(pHead);
28.
return;
29. }
七、C语言和设计模式（观察者模式）
观察者模式可能是我们在软件开发中使用得比较多的一种设计模式。为什么这么说？大家可以听我一一到来。我们知道，在windows的软件中，所有的界都是由窗口构成的。对话框是窗口，菜单是窗口，工具栏也是窗口。那么这些窗口，在很多情况下要对一些共有的信息进行处理。比如说，窗口的放大，窗口的减小等等。面对这一情况，观察者模式就是不错的一个选择。
首先，我们可以对这些共有的object进行提炼。
\[cpp\] view plaincopy
1. typedef struct _Object
2. {
3.
observer* pObserverList[MAX_BINDING_NUMBER];
4.
int number;
5.
6.
void (*notify)(struct _Object* pObject);
7.
void (*add_observer)(observer* pObserver);
8.
void (*del_observer)(observer* pObserver);
9.
10. }Object;
其实，我们需要定义的就是观察者本身了。就像我们前面说的一样，观察者可以是菜单、工具栏或者是子窗口等等。
\[cpp\] view plaincopy
11. typedef struct _Observer
12. {
13.
Object* pObject;
14.
15.
void (*update)(struct _Observer* pObserver);
16. }Observer;
紧接着，我们要做的就是在Observer创建的时候，把observer自身绑定到Object上面。
\[cpp\] view plaincopy
17. void bind_observer_to_object(Observer\* pObserver, Object\* pObject)
18. {
19.
assert(NULL != pObserver && NULL != pObject);
20.
21.
pObserver->pObject = pObject;
22.
pObject->add_observer(pObserver);
23. }
24.
25. void unbind_observer_from_object(Observer\* pObserver, Object\* pObject)
26. {
27.
assert(NULL != pObserver && NULL != pObject);
28.
29.
pObject->del_observer(observer* pObserver);
30.
memset(pObserver, 0, sizeof(Observer));
31. }
既然Observer在创建的时候就把自己绑定在某一个具体的Object上面，那么Object发生改变的时候，统一更新操作就是一件很容易的事情了。
\[cpp\] view plaincopy
32. void notify(struct _Object\* pObject)
33. {
34.
Obserer* pObserver;
35.
int index;
36.
37.
assert(NULL != pObject);
38.
for(index = 0; index < pObject->number; index++)
39.
{
40.
pObserver = pObjecet->pObserverList[index];
41.
pObserver->update(pObserver);
42.
}
43. }
八、C语言和设计模式（桥接模式）
在以往的软件开发过程中，我们总是强调模块之间要低耦合，模块本身要高内聚。那么，可以通过哪些设计模式来实现呢？桥接模式就是不错的一个选择。我们知道，在现实的软件开发过程当中，用户的要求是多种多样的。比如说，有这么一个饺子店吧。假设饺子店原来只卖肉馅的饺子，可是后来一些吃素的顾客说能不能做一些素的饺子。听到这些要求的老板自然不敢怠慢，所以也开始卖素饺子。之后，又有顾客提出，现在的肉馅饺子只有猪肉的，能不能做点牛肉、羊肉馅的饺子？一些只吃素的顾客也有意见了，他们建议能不能增加一些素馅饺子的品种，什么白菜馅的、韭菜馅的，都可以做一点。由此看来，顾客的要求是一层一层递增的。关键是我们如何把顾客的要求和我们的实现的接口进行有效地分离呢？
其实我们可以这么做，通常的产品还是按照共同的属性进行归类。
\[cpp\] view plaincopy
1. typedef struct _MeatDumpling
2. {
3.
void (*make)();
4. }MeatDumpling;
5.
6. typedef struct _NormalDumpling
7. {
8.
void (*make)();
9. }NormalDumpling;
上面只是对饺子进行归类。第一类是对肉馅饺子的归类，第二类是对素馅饺子的归类，这些地方都没有什么特别之处。那么，关键是我们怎么把它和顾客的要求联系在一起呢？
\[cpp\] view plaincopy
10. typedef struct _DumplingReuqest
11. {
12.
int type;
13.
void* pDumpling;
14. }DumplingRequest;
这里定义了一个饺子买卖的接口。它的特别支持就在于两个地方，第一是我们定义了饺子的类型type，这个type是可以随便扩充的；第二就是这里的pDumpling是一个void\*指针，只有把它和具体的dumpling绑定才会衍生出具体的含义。
\[cpp\] view plaincopy
15. void buy_dumpling(DumplingReuqest\* pDumplingRequest)
16. {
17.
assert(NULL != pDumplingRequest);
18.
19.
if(MEAT_TYPE == pDumplingRequest->type)
20.
return (MeatDumpling*)(pDumplingRequest->pDumpling)->make();
21.
else
22.
return (NormalDumpling*)(pDumplingRequest->pDumpling)->make();
23. }
九、C语言和设计模式（建造者模式）
如果说前面的工厂模式是对接口进行抽象化处理，那么建造者模式更像是对流程本身的一种抽象化处理。这话怎么理解呢？大家可以听我慢慢到来。以前买电脑的时候，大家都喜欢自己组装机器。一方面可以满足自己的个性化需求，另外一方面也可以在价格上得到很多实惠。但是电脑是由很多部分组成的，每个厂家都只负责其中的一部分，而且相同的组件也有很多的品牌可以从中选择。这对于我们消费者来说当然非常有利，那么应该怎么设计呢？
\[cpp\] view plaincopy
1. typedef struct _AssemblePersonalComputer
2. {
3.
void (*assemble_cpu)();
4.
void (*assemble_memory)();
5.
void (*assemble_harddisk)();
6.
7. }AssemblePersonalComputer;
对于一个希望配置intel cpu，samsung 内存、日立硬盘的朋友。他可以这么设计，
\[cpp\] view plaincopy
8. void assemble_intel_cpu()
9. {
10.
printf("intel cpu!\n");
11. }
12.
13. void assemble_samsung_memory()
14. {
15.
printf("samsung memory!\n");
16. }
17.
18. void assemble_hitachi_harddisk()
19. {
20.
printf("hitachi harddisk!\n");
21. }
而对于一个希望配置AMD cpu, kingston内存、西部数据硬盘的朋友。他又该怎么做呢？
\[cpp\] view plaincopy
22. void assemble_amd_cpu()
23. {
24.
printf("amd cpu!\n");
25. }
26.
27. void assemble_kingston_memory()
28. {
29.
printf("kingston memory!\n");
30. }
31.
32. void assmeble_western_digital_harddisk()
33. {
34.
printf("western digital harddisk!\n");
35. }
十、 C语言和设计模式（中介者模式）
中介者模式，听上去有一点陌生。但是，只要我给朋友们打个比方就明白了。早先自由恋爱没有现在那么普遍的时候，男女之间的相识还是需要通过媒婆之间才能相互认识。男孩对女方有什么要求，可以通过媒婆向女方提出来；当然，女方有什么要求也可以通过媒婆向男方提出来。所以，中介者模式在我看来，就是媒婆模式。
\[cpp\] view plaincopy
1. typedef struct _Mediator
2. {
3.
People* man;
4.
People* woman;
5. }Mediator;
上面的数据结构是给媒婆的，那么当然还有一个数据结构是给男方、女方的。
\[cpp\] view plaincopy
6. typedef struct _People
7. {
8.
Mediator* pMediator;
9.
10.
void (*request)(struct _People* pPeople);
11.
void (*process)(struct _Peoplle* pPeople);
12. }People;
所以，这里我们看到的如果是男方的要求，那么这个要求应该女方去处理啊，怎么处理呢？
\[cpp\] view plaincopy
13. void man_request(struct _People\* pPeople)
14. {
15.
assert(NULL != pPeople);
16.
17.
pPeople->pMediator->woman->process(pPeople->pMediator->woman);
18. }
上面做的是男方向女方提出的要求，所以女方也可以向男方提要求了。毕竟男女平等嘛。
\[cpp\] view plaincopy
19. void woman_request(struct _People\* pPeople)
20. {
21.
assert(NULL != pPeople);
22.
23.
pPeople->pMediator->man->process(pPeople->pMediator->man);
24. }
十一、C语言和设计模式（策略模式）
策略模式就是用统一的方法接口分别对不同类型的数据进行访问。比如说，现在我们想用pc看一部电影，此时应该怎么做呢？看电影嘛，当然需要各种播放电影的方法。rmvb要rmvb格式的方法，avi要avi的方法,mpeg要mpeg的方法。可是事实上，我们完全可以不去管是什么文件格式。因为播放器对所有的操作进行了抽象，不同的文件会自动调用相应的访问方法。
\[cpp\] view plaincopy
1. typedef struct _MoviePlay
2. {
3.
struct _CommMoviePlay* pCommMoviePlay;
4.
5. }MoviePlay;
6.
7. typedef struct _CommMoviePlay
8. {
9.
HANDLE hFile;
10.
void (*play)(HANDLE hFile);
11.
12. }CommMoviePlay;
这个时候呢，对于用户来说，统一的文件接口就是MoviePlay。接下来的一个工作，就是编写一个统一的访问接口。
\[cpp\] view plaincopy
13. void play_movie_file(struct MoviePlay\* pMoviePlay)
14. {
15.
CommMoviePlay* pCommMoviePlay;
16.
assert(NULL != pMoviePlay);
17.
18.
pCommMoviePlay = pMoviePlay->pCommMoviePlay;
19.
pCommMoviePlay->play(pCommMoviePlay->hFile);
20. }
最后的工作就是对不同的hFile进行play的实际操作，写简单一点就是，
\[cpp\] view plaincopy
21. void play_avi_file(HANDLE hFile)
22. {
23.
printf("play avi file!\n");
24. }
25.
26. void play_rmvb_file(HANDLE hFile)
27. {
28.
printf("play rmvb file!\n");
29. }
30.
31. void play_mpeg_file(HANDLE hFile)
32. {
33.
printf("play mpeg file!\n");
34. }
十二、C语言和设计模式（适配器模式）
现在的生活当中，我们离不开各种电子工具。什么笔记本电脑、手机、mp4啊，都离不开充电。既然是充电，那么就需要用到充电器。其实从根本上来说，充电器就是一个个普通的适配器。什么叫适配器呢，就是把220v、50hz的交流电压编程5\~12v的直流电压。充电器就干了这么一件事情。
那么，这样的一个充电适配器，我们应该怎么用c++描述呢？
\[cpp\] view plaincopy
1. class voltage_12v
2. {
3. public:
4.
voltage_12v() {}
5.
virtual ~voltage_12v() {}
6.
virtual void request() {}
7. };
8.
9. class v220_to_v12
10. {
11. public:
12.
v220_to_v12() {}
13.
~v220_to_v12() {}
14.
void voltage_transform_process() {}
15. };
16.
17. class adapter: public voltage_12v
18. {
19.
v220_to_v12* pAdaptee;
20.
21. public:
22.
adapter() {}
23.
~adapter() {}
24.
25.
void request()
26.
{
27.
pAdaptee->voltage_transform_process();
28.
}
29. };
通过上面的代码，我们其实可以这样理解。类voltage_12v表示我们的最终目的就是为了获得一个12v的直流电压。当然获得12v可以有很多的方法，利用适配器转换仅仅是其中的一个方法。adapter表示适配器，它自己不能实现220v到12v的转换工作，所以需要调用类v220_to_v12的转换函数。所以，我们利用adapter获得12v的过程，其实就是调用v220_to_v12函数的过程。
不过，既然我们的主题是用c语言来编写适配器模式，那么我们就要实现最初的目标。这其实也不难，关键一步就是定义一个Adapter的数据结构。然后把所有的Adapter工作都由Adaptee来做，就是这么简单。不知我说明白了没有？
\[cpp\] view plaincopy
30. typdef struct _Adaptee
31. {
32.
void (*real_process)(struct _Adaptee* pAdaptee);
33. }Adaptee;
34.
35. typedef struct _Adapter
36. {
37.
void* pAdaptee;
38.
void (*transform_process)(struct _Adapter* pAdapter);
39.
40. }Adapter;
十三、 C语言和设计模式（装饰模式）
装饰模式是比较好玩，也比较有意义。其实就我个人看来，它和责任链还是蛮像的。只不过一个是比较判断，一个是迭代处理。装饰模式就是那种迭代处理的模式，关键在哪呢？我们可以看看数据结构。
\[cpp\] view plaincopy
1. typedef struct _Object
2. {
3.
struct _Object* prev;
4.
5.
void (*decorate)(struct _Object* pObject);
6. }Object;
装饰模式最经典的地方就是把pObject这个值放在了数据结构里面。当然，装饰模式的奥妙还不仅仅在这个地方，还有一个地方就是迭代处理。我们可以自己随便写一个decorate函数试试看，
\[cpp\] view plaincopy
7. void decorate(struct _Object\* pObeject)
8. {
9.
assert(NULL != pObject);
10.
11.
if(NULL != pObject->prev)
12.
pObject->prev->decorate(pObject->prev);
13.
14.
printf("normal decorate!\n");
15. }
所以，装饰模式的最重要的两个方面就体现在：prev参数和decorate迭代处理。
十四、 C语言和设计模式（享元模式）
享元模式看上去有点玄乎，但是其实也没有那么复杂。我们还是用示例说话。比如说，大家在使用电脑的使用应该少不了使用WORD软件。使用WORD呢， 那就少不了设置模板。什么模板呢，比如说标题的模板，正文的模板等等。这些模板呢，又包括很多的内容。哪些方面呢，比如说字体、标号、字距、行距、大小等等。
\[cpp\] view plaincopy
16. typedef struct _Font
17. {
18.
int type;
19.
int sequence;
20.
int gap;
21.
int lineDistance;
22.
23.
void (*operate)(struct _Font* pFont);
24.
25. }Font;
上面的Font表示了各种Font的模板形式。所以，下面的方法就是定制一个FontFactory的结构。
\[cpp\] view plaincopy
26. typedef struct _FontFactory
27. {
28.
Font** ppFont;
29.
int number;
30.
int size;
31.
32.
Font* GetFont(struct _FontFactory* pFontFactory, int type, int sequence, int gap, int lineDistance);
33. }FontFactory;
这里的GetFont即使对当前的Font进行判断，如果Font存在，那么返回；否则创建一个新的Font模式。
\[cpp\] view plaincopy
34. Font\* GetFont(struct _FontFactory\* pFontFactory, int type, int sequence, int gap, int lineDistance)
35. {
36.
int index;
37.
Font* pFont;
38.
Font* ppFont;
39.
40.
if(NULL == pFontFactory)
41.
return NULL;
42.
43.
for(index = 0; index < pFontFactory->number; index++)
44.
{
45.
if(type != pFontFactory->ppFont[index]->type)
46.
continue;
47.
48.
if(sequence != pFontFactory->ppFont[index]->sequence)
49.
continue;
50.
51.
if(gap != pFontFactory->ppFont[index]->gap)
52.
continue;
53.
54.
if(lineDistance != pFontFactory->ppFont[index]->lineDistance)
55.
continue;
56.
57.
return pFontFactory->ppFont[index];
58.
}
59.
60.
pFont = (Font*)malloc(sizeof(Font));
61.
assert(NULL != pFont);
62.
pFont->type = type;
63.
pFont->sequence = sequence;
64.
pFont->gap = gap;
65.
pFont->lineDistance = lineDistance;
66.
67.
if(pFontFactory-> number < pFontFactory->size)
68.
{
69.
pFontFactory->ppFont[index] = pFont;
70.
pFontFactory->number ++;
71.
return pFont;
72.
}
73.
74.
ppFont = (Font**)malloc(sizeof(Font*) * pFontFactory->size * 2);
75.
assert(NULL != ppFont);
76.
memmove(ppFont, pFontFacoty->ppFont, pFontFactory->size);
77.
free(pFontFactory->ppFont);
78.
pFontFactory->size *= 2;
79.
pFontFactory->number ++;
80.
ppFontFactory->ppFont = ppFont;
81.
return pFont;
82. }
十五、 C语言和设计模式（代理模式）
代理模式是一种比较有意思的设计模式。它的基本思路也不复杂。举个例子来说，以前在学校上网的时候，并不是每一台pc都有上网的权限的。比如说，现在有pc1、pc2、pc3，但是只有pc1有上网权限，但是pc2、pc3也想上网，此时应该怎么办呢？
此时，我们需要做的就是在pc1上开启代理软件，同时把pc2、pc3的IE代理指向pc1即可。这个时候，如果pc2或者pc3想上网，那么报文会先指向pc1，然后pc1把Internet传回的报文再发给pc2或者pc3。这样一个代理的过程就完成了整个的上网过程。
在说明完整的过程之后，我们可以考虑一下软件应该怎么编写呢？
\[cpp\] view plaincopy
1. typedef struct _PC_Client
2. {
3.
void (*request)();
4. }PC_Client;
5.
6. void ftp_request()
7. {
8.
printf("request from ftp!\n");
9. }
10.
11. void http_request()
12. {
13.
printf("request from http!\n");
14. }
15.
16. void smtp_request()
17. {
18.
printf("request from smtp!\n");
19. }
这个时候，代理的操作应该怎么写呢？怎么处理来自各个协议的请求呢？
\[cpp\] view plaincopy
20. typedef struct _Proxy
21. {
22.
PC_Client* pClient;
23. }Proxy;
24.
25. void process(Proxy\* pProxy)
26. {
27.
assert(NULL != pProxy);
28.
29.
pProxy->pClient->request();
30. }
十六、C语言和设计模式（外观模式）
外观模式是比较简单的模式。它的目的也是为了简单。什么意思呢？举个例子吧。以前，我们逛街的时候吃要到小吃一条街，购物要到购物一条街，看书、看电影要到文化一条街。那么有没有这样的地方，既可以吃喝玩乐，同时相互又靠得比较近呢。其实，这就是悠闲广场，遍布全国的万达广场就是干了这么一件事。
首先，我们原来是怎么做的。
\[cpp\] view plaincopy
1. typedef struct _FoodSteet
2. {
3.
void (*eat)();
4. }FoodStreet;
5.
6. void eat()
7. {
8.
printf("eat here!\n");
9. }
10.
11. typedef struct _ShopStreet
12. {
13.
void (*buy)();
14. }ShopStreet;
15.
16. void buy()
17. {
18.
printf("buy here!\n");
19. }
20.
21. typedef struct _BookStreet
22. {
23.
void (*read)();
24. }BookStreet;
25.
26. void read()
27. {
28.
printf("read here");
29. }
下面，我们就要在一个plaza里面完成所有的项目，怎么办呢？
\[cpp\] view plaincopy
30. typedef struct _Plaza
31. {
32.
FoodStreet* pFoodStreet;
33.
ShopStreet* pShopStreet;
34.
BookStreet* pBookStreet;
35.
36.
void (*play)(struct _Plaza* pPlaza);
37. }Plaza;
38.
39. void play(struct _Plaza\* pPlaza)
40. {
41.
assert(NULL != pPlaza);
42.
43.
pPlaza->pFoodStreet->eat();
44.
pPlaza->pShopStreet->buy();
45.
pPlaza->pBookStreet->read();
46. }
十七、 C语言和设计模式（迭代器模式）
使用过C++的朋友大概对迭代器模式都不会太陌生。这主要是因为我们在编写代码的时候离不开迭代器，队列有迭代器，向量也有迭代器。那么，为什么要迭代器呢？这主要是为了提炼一种通用的数据访问方法。
比如说，现在有一个数据的容器，
\[cpp\] view plaincopy
1. typedef struct _Container
2. {
3.
int* pData;
4.
int size;
5.
int length;
6.
7.
Interator* (*create_new_interator)(struct _Container* pContainer);
8.
int (*get_first)(struct _Container* pContainer);
9.
int (*get_last)(struct _Container* pContainer);
10.
11. }Container;
我们看到，容器可以创建迭代器。那什么是迭代器呢？
\[cpp\] view plaincopy
12. typedef struct _Interator
13. {
14.
void* pVector;
15.
int index;
16.
17.
int(* get_first)(struct _Interator* pInterator);
18.
int(* get_last)(struct _Interator* pInterator);
19. }Interator;
我们看到，容器有get_first，迭代器也有get_first，这中间有什么区别？
\[cpp\] view plaincopy
20. int vector_get_first(struct _Container\* pContainer)
21. {
22.
assert(NULL != pContainer);
23.
24.
return pContainer->pData[0];
25. }
26.
27. int vector_get_last(struct _Container\* pContainer)
28. {
29.
assert(NULL != pContainer);
30.
31.
return pContainer->pData[pContainer->size -1];
32. }
33.
34. int vector_interator_get_first(struct _Interator\* pInterator)
35. {
36.
Container* pContainer;
37.
assert(NULL != pInterator && NULL != pInterator->pVector);
38.
39.
pContainer = (struct _Container*) (pInterator->pVector);
40.
return pContainer ->get_first(pContainer);
41. }
42.
43. int vector_interator_get_last(struct _Interator\* pInterator)
44. {
45.
Container* pContainer;
46.
assert(NULL != pInterator && NULL != pInterator->pVector);
47.
48.
pContainer = (struct _Container*) (pInterator->pVector);
49.
return pContainer ->get_last(pContainer);
50. }
看到上面的代码之后，我们发现迭代器的操作实际上也是对容器的操作而已。
十八、 C语言和设计模式（抽象工厂模式）
前面我们写过的工厂模式实际上是对产品的抽象。对于不同的用户需求，我们可以给予不同的产品，而且这些产品的接口都是一致的。而抽象工厂呢？顾名思义，就是说我们的工厂是不一定的。怎么理解呢，举个例子。
假设有两个水果店都在卖水果，都卖苹果和葡萄。其中一个水果店买白苹果和白葡萄，另外一个水果店卖红苹果和红葡萄。所以说，对于水果店而言，尽管都在卖水果，但是两个店卖的品种不一样。
既然水果不一样，那我们先定义水果。
\[cpp\] view plaincopy
1. typedef struct _Apple
2. {
3.
void (*print_apple)();
4. }Apple;
5.
6. typedef struct _Grape
7. {
8.
void (*print_grape)();
9. }Grape;
上面分别对苹果和葡萄进行了抽象，当然它们的具体函数也是不一样的。
\[cpp\] view plaincopy
10. void print_white_apple()
11. {
12.
printf("white apple!\n");
13. }
14.
15. void print_red_apple()
16. {
17.
printf("red apple!\n");
18. }
19.
20. void print_white_grape()
21. {
22.
printf("white grape!\n");
23. }
24.
25. void print_red_grape()
26. {
27.
printf("red grape!\n");
28. }
完成了水果函数的定义。下面就该定义工厂了，和水果一样，我们也需要对工厂进行抽象处理。
\[cpp\] view plaincopy
29. typedef struct _FruitShop
30. {
31.
Apple* (*sell_apple)();
32.
Apple* (*sell_grape)();
33. }FruitShop;
所以，对于卖白苹果、白葡萄的水果店就该这样设计了，红苹果、红葡萄的水果店亦是如此。
\[cpp\] view plaincopy
34. Apple\* sell_white_apple()
35. {
36.
Apple* pApple = (Apple*) malloc(sizeof(Apple));
37.
assert(NULL != pApple);
38.
39.
pApple->print_apple = print_white_apple;
40.
return pApple;
41. }
42.
43. Grape\* sell_white_grape()
44. {
45.
Grape* pGrape = (Grape*) malloc(sizeof(Grape));
46.
assert(NULL != pGrape);
47.
48.
pGrape->print_grape = print_white_grape;
49.
return pGrape;
50. }
这样，基本的框架就算搭建完成的，以后创建工厂的时候，
\[cpp\] view plaincopy
51. FruitShop\* create_fruit_shop(int color)
52. {
53.
FruitShop* pFruitShop = (FruitShop*) malloc(sizeof(FruitShop));
54.
assert(NULL != pFruitShop);
55.
56.
if(WHITE == color)
57.
{
58.
pFruitShop->sell_apple = sell_white_apple;
59.
pFruitShop->sell_grape = sell_white_grape;
60.
}
61.
else
62.
{
63.
pFruitShop->sell_apple = sell_red_apple;
64.
pFruitShop->sell_grape = sell_red_grape;
65.
}
66.
67.
return pFruitShop;
68. }
十九、 C语言和设计模式（责任链模式）
责任链模式是很实用的一种实际方法。举个例子来说，我们平常在公司里面难免不了报销流程。但是，我们知道公司里面每一级的领导的报批额度是不一样的。比如说，科长的额度是1000元，部长是10000元，总经理是10万元。
那么这个时候，我们应该怎么设计呢？其实可以这么理解。比如说，有人来找领导报销费用了，那么领导可以自己先看看自己能不能报。如果费用可以顺利报下来当然最好，可是万一报不下来呢？那就只能请示领导的领导了。
\[cpp\] view plaincopy
1. typedef struct _Leader
2. {
3.
struct _Leader* next;
4.
int account;
5.
6.
int (*request)(strcut _Leader* pLeader, int num);
7. }Leader;
所以这个时候，我们首先需要设置额度和领导。
\[cpp\] view plaincopy
1. void set_account(struct _Leader\* pLeader, int account)
2. {
3.
assert(NULL != pLeader);
4.
5.
pLeader->account = account;
6.
return;
7. }
8.
9. void set_next_leader(const struct _Leader\* pLeader, struct _Leader\* next)
10. {
11.
assert(NULL != pLeader && NULL != next);
12.
13.
pLeader->next = next;
14.
return;
15. }
此时，如果有一个员工过来报销费用，那么应该怎么做呢？假设此时的Leader是经理，报销额度是10万元。所以此时，我们可以看看报销的费用是不是小于10万元？少于这个数就OK，反之就得上报自己的领导了。
\[cpp\] view plaincopy
16. int request_for_manager(struct _Leader\* pLeader, int num)
17. {
18.
assert(NULL != pLeader && 0 != num);
19.
20.
if(num < 100000)
21.
return 1;
22.
else if(pLeader->next)
23.
return pLeader->next->request(pLeader->next, num);
24.
else
25.
return 0;
26. }
二十、 C语言和设计模式（工厂模式）
工厂模式是比较简单，也是比较好用的一种方式。根本上说，工厂模式的目的就根据不同的要求输出不同的产品。比如说吧，有一个生产鞋子的工厂，它能生产皮鞋，也能生产胶鞋。如果用代码设计，应该怎么做呢？
\[cpp\] view plaincopy
1. typedef struct _Shoe
2. {
3.
int type;
4.
void (*print_shoe)(struct _Shoe*);
5. }Shoe;
就像上面说的，现在有胶鞋，那也有皮鞋，我们该怎么做呢？
\[cpp\] view plaincopy
6. void print_leather_shoe(struct _Shoe\* pShoe)
7. {
8.
assert(NULL != pShoe);
9.
printf("This is a leather show!\n");
10. }
11.
12. void print_rubber_shoe(struct _Shoe\* pShoe)
13. {
14.
assert(NULL != pShoe);
15.
printf("This is a rubber shoe!\n");
16. }
所以，对于一个工厂来说，创建什么样的鞋子，就看我们输入的参数是什么？至于结果，那都是一样的。
\[cpp\] view plaincopy
17. #define LEATHER_TYPE 0x01
18. #define RUBBER_TYPE 0x02
19.
20. Shoe\* manufacture_new_shoe(int type)
21. {
22.
assert(LEATHER_TYPE == type || RUBBER_TYPE == type);
23.
24.
Shoe* pShoe = (Shoe*)malloc(sizeof(Shoe));
25.
assert(NULL != pShoe);
26.
27.
memset(pShoe, 0, sizeof(Shoe));
28.
if(LEATHER_TYPE == type)
29.
{
30.
pShoe->type == LEATHER_TYPE;
31.
pShoe->print_shoe = print_leather_shoe;
32.
}
33.
else
34.
{
35.
pShoe->type == RUBBER_TYPE;
36.
pShoe->print_shoe = print_rubber_shoe;
37.
}
38.
39.
return pShoe;
40. }
二十一、 C语言和设计模式（之模板模式）
模板对于学习C++的同学，其实并不陌生。函数有模板函数，类也有模板类。那么这个模板模式是个什么情况？我们可以思考一下，模板的本质是什么。比如说，现在我们需要编写一个简单的比较模板函数。
\[cpp\] view plaincopy
1. template
2. int compare (type a, type b)
3. {
4.
return a > b ? 1 : 0;
5. }
模板函数提示我们，只要比较的逻辑是确定的，那么不管是什么数据类型，都会得到一个相应的结果。固然，这个比较的流程比较简单，即使没有采用模板函数也没有关系。但是，要是需要拆分的步骤很多，那么又该怎么办呢？如果相通了这个问题，那么也就明白了什么是template模式。
比方说，现在我们需要设计一个流程。这个流程有很多小的步骤完成。然而，其中每一个步骤的方法是多种多样的，我们可以很多选择。但是，所有步骤构成的逻辑是唯一的，那么我们该怎么办呢？其实也简单。那就是在基类中除了流程函数外，其他的步骤函数全部设置为virtual函数即可。
\[cpp\] view plaincopy
6. class basic
7. {
8. public:
9.
void basic() {}
10.
virtual ~basic() {}
11.
virtual void step1() {}
12.
virtual void step2() {}
13.
void process()
14.
{
15.
step1();
16.
step2();
17.
}
18. };
basic的类说明了基本的流程process是唯一的，所以我们要做的就是对step1和step2进行改写。
\[cpp\] view plaincopy
19. class data_A : public basic
20. {
21. public:
22.
data_A() {}
23.
~data_A() {}
24.
void step1()
25.
{
26.
printf("step 1 in data_A!\n");
27.
}
28.
29.
void step2()
30.
{
31.
printf("step 2 in data_A!\n");
32.
}
33. };
所以，按照我个人的理解，这里的template主要是一种流程上的统一，细节实现上的分离。明白了这个思想，那么用C语言来描述template模式就不是什么难事了。
\[cpp\] view plaincopy
34. typedef struct _Basic
35. {
36.
void* pData;
37.
void (*step1) (struct _Basic* pBasic);
38.
void (*step2) (struct _Basic* pBasic);
39.
void (*process) (struct _Basic* pBasic);
40. }Basic;
因为在C++中process函数是直接继承的，C语言下面没有这个机制。所以，对于每一个process来说，process函数都是唯一的，但是我们每一次操作的时候还是要去复制一遍函数指针。而step1和step2是不同的，所以各种方法可以用来灵活修改自己的处理逻辑，没有问题。
\[cpp\] view plaincopy
41. void process(struct _Basic\* pBasic)
42. {
43.
pBasic->step1(pBasic);
44.
pBasic->step2(pBasic);
45. }
二十二、C语言和设计模式（之组合模式）
组合模式听说去很玄乎，其实也并不复杂。为什么?大家可以先想一下数据结构里面的二叉树是怎么回事。为什么就是这么一个简单的二叉树节点既可能是叶节点，也可能是父节点?
\[cpp\] view plaincopy
1. typedef struct _NODE
2. {
3.
void* pData;
4.
struct _NODE* left;
5.
struct _NODE* right;
6. }NODE;
那什么时候是叶子节点，其实就是left、right为NULL的时候。那么如果它们不是NULL呢，那么很明显此时它们已经是父节点了。那么，我们的这个组合模式是怎么一个情况呢？
\[cpp\] view plaincopy
7. typedef struct _Object
8. {
9.
struct _Object** ppObject;
10.
int number;
11.
void (*operate)(struct _Object* pObject);
12.
13. }Object;
就是这么一个简单的数据结构，是怎么实现子节点和父节点的差别呢。比如说，现在我们需要对一个父节点的operate进行操作，此时的operate函数应该怎么操作呢？
\[cpp\] view plaincopy
14. void operate_of_parent(struct _Object\* pObject)
15. {
16.
int index;
17.
assert(NULL != pObject);
18.
assert(NULL != pObject->ppObject && 0 != pObject->number);
19.
20.
for(index = 0; index < pObject->number; index ++)
21.
{
22.
pObject->ppObject[index]->operate(pObject->ppObject[index]);
23.
}
24. }
当然，有了parent的operate，也有child的operate。至于是什么操作，那就看自己是怎么操作的了。
\[cpp\] view plaincopy
1. void operate_of_child(struct _Object\* pObject)
2. {
3.
assert(NULL != pObject);
4.
printf("child node!\n");
5. }
父节点也好，子节点也罢，一切的一切都是最后的应用。其实，用户的调用也非常简单，就这么一个简单的函数。
\[cpp\] view plaincopy
1. void process(struct Object\* pObject)
2. {
3.
assert(NULL != pObject);
4.
pObject->operate(pObject);
5. }
二十三、C语言和设计模式（之原型模式）
原型模式本质上说就是对当前数据进行复制。就像变戏法一样，一个鸽子变成了两个鸽子，两个鸽子变成了三个鸽子，就这么一直变下去。在变的过程中，我们不需要考虑具体的数据类型。为什么呢？因为不同的数据有自己的复制类型，而且每个复制函数都是虚函数。
用C++怎么编写呢，那就是先写一个基类，再编写一个子类。就是这么简单。
\[cpp\] view plaincopy
1. class data
2. {
3. public:
4.
data () {}
5.
virtual ~data() {}
6.
virtual class data* copy() = 0;
7. };
8.
9. class data_A : public data
10. {
11. public:
12.
data_A() {}
13.
~data_A() {}
14.
class data* copy()
15.
{
16.
return new data_A();
17.
}
18. };
19.
20. class data_B : public data
21. {
22. public:
23.
data_B() {}
24.
~data_B() {}
25.
class data* copy()
26.
{
27.
return new data_B();
28.
}
29. };
那怎么使用呢？其实只要一个通用的调用接口就可以了。
\[cpp\] view plaincopy
30. class data\* clone(class data\* pData)
31. {
32.
return pData->copy();
33. }
就这么简单的一个技巧，对C来说，当然也不是什么难事。
\[cpp\] view plaincopy
34. typedef struct _DATA
35. {
36.
struct _DATA* (*copy) (struct _DATA* pData);
37. }DATA;
假设也有这么一个类型data_A,
\[cpp\] view plaincopy
38. DATA data_A = {data_copy_A};
既然上面用到了这个函数，所以我们也要定义啊。
\[cpp\] view plaincopy
39. struct _DATA\* data_copy_A(struct _DATA\* pData)
40. {
41.
DATA* pResult = (DATA*)malloc(sizeof(DATA));
42.
assert(NULL != pResult);
43.
memmove(pResult, pData, sizeof(DATA));
44.
return pResult;
45. };
使用上呢，当然也不含糊。
\[cpp\] view plaincopy
46. struct _DATA\* clone(struct _DATA\* pData)
47. {
48.
return pData->copy(pData);
49. };
二十四、C语言和设计模式（之单件模式）
有过面试经验的朋友，或者对设计模式有点熟悉的朋友，都会对单件模式不陌生。对很多面试官而言，单件模式更是他们面试的保留项目。其实，我倒认为，单件模式算不上什么设计模式。最多也就是个技巧。
单件模式要是用C++写，一般这么写。
\[cpp\] view plaincopy
1. #include \