【 C语言】 C语言设计模式

大家好，欢迎来到IT知识分享网。

一、C语言和设计模式（继承、封装、多态）

typedef struct _parent
{
```
 int data_parent; 
```
}Parent;
typedef struct _Child
{
```
 struct _parent parent; 
```
```
int data_child; 
```
}Child;
在设计C语言继承性的时候，我们需要做的就是把基础数据放在继承的结构的首位置即可。这样，不管是数据的访问、数据的强转、数据的访问都不会有什么问题。

struct _Data;
typedef void (process)(struct _Data pData);
typedef struct _Data
{
```
 int value; 
```
```
 process pProcess; 
```
}Data;
封装性的意义在于，函数和数据是绑在一起的，数据和数据是绑在一起的。这样，我们就可以通过简单的一个结构指针访问到所有的数据，遍历所有的函数。封装性，这是类拥有的属性，当然也是数据结构体拥有的属性。

typedef struct _Play
{
```
 void* pData; 
```

 void (*start_play)(struct _Play* pPlay);

}Play;
多态，就是说用同一的接口代码处理不同的数据。比如说，这里的Play结构就是一个通用的数据结构，我们也不清楚pData是什么数据，start_play是什么处理函数？但是，我们处理的时候只要调用pPlay->start_play(pPlay)就可以了。剩下来的事情我们不需要管，因为不同的接口会有不同的函数去处理，我们只要学会调用就可以了。

typedef struct _Tofu
{
```
 int type; 
```

 void (*eat) (struct _Visitor* pVisitor, struct _Tofu* pTofu);

}Tofu;
typedef struct _Visitor
{
```
 int region; 
```

void (*process)(struct _Tofu* pTofu, struct _Visitor* pVisitor);

}Visitor;
就是这样一个豆腐，eat的时候就要做不同的判断了。
[cpp] view plaincopy
void eat(struct _Visitor* pVisitor, struct _Tofu* pTofu)
{

 assert(NULL != pVisitor && NULL != pTofu);

```
 pVisitor->process(pTofu, pVisitor); 
```
}
既然eat的操作最后还是靠不同的visitor来处理了，那么下面就该定义process函数了。
[cpp] view plaincopy
void process(struct _Tofu* pTofu, struct _Visitor* pVisitor)
{

 assert(NULL != pTofu && NULL != pVisitor);

 if(pTofu->type == SPICY_FOOD && pVisitor->region == WEST ||

 pTofu->type == STRONG_SMELL_FOOD && pVisitor->region == EAST)

```
 { 
```
```
 printf("I like this food!\n"); 
```
```
 return; 
```
```
} 
```
```
printf("I hate this food!\n"); 
```
}

typedef struct _State
{
```
 void (*process)(); 
```
```
 struct _State* (*change_state)(); 
```
}State;
说明一下，这里定义了两个变量，分别process函数和change_state函数。其中proces函数就是普通的数据操作，
[cpp] view plaincopy
void normal_process()
{
```
 printf("normal process!\n"); 
```
}
change_state函数本质上就是确定下一个状态是什么。
[cpp] view plaincopy
struct _State* change_state()
{
```
 State* pNextState = NULL; 
```

 pNextState = (struct _State*)malloc(sizeof(struct _State));

```
 assert(NULL != pNextState); 
```
```
 pNextState ->process = next_process; 
```

 pNextState ->change_state = next_change_state;

```
return pNextState; 
```
}
所以，在context中，应该有一个state变量，还应该有一个state变换函数。
[cpp] view plaincopy
typedef struct _Context
{
```
 State* pState; 
```

 void (*change)(struct _Context* pContext);

}Context;
void context_change(struct _Context* pContext)
{
```
State* pPre; 
```
```
assert(NULL != pContext); 
```
```
pPre = pContext->pState; 
```

pContext->pState = pPre->changeState();

```
free(pPre); 
```
```
return; 
```
}

首先定义post的相关数据。

[cpp] view plaincopy

typedef struct _Post
{
```
 void (*do)(struct _Post* pPost); 
```
}Post;
Post完成了实际的投递工作，那么命令呢？
[cpp] view plaincopy
typedef struct _Command
{
```
 void* pData; 
```

 void (*exe)(struct _Command* pCommand);

}Command;
void post_exe(struct _Command* pCommand)
{
```
assert(NULL != pCommand); 
```

(Post*)(pCommand->pData)->do((Post*)(pCommand->pData));

```
return; 
```
}
我们看到了Post、Command的操作，那么剩下的就是boss的定义了。
[cpp] view plaincopy
typedef struct _Boss
{
```
 Command* pCommand; 
```
```
 void (*call)(struct _Boss* pBoss); 
```
}Boss;
void boss_call(struct _Boss* pBoss)
{
```
 assert(NULL != pBoss); 
```
```
pBoss->pCommand->exe(pBoss->pCommand); 
```
```
return; 
```
}

typedef struct _Interpret
{
```
 int type; 
```

 void* (*process)(void* pData, int* type, int* result);

}Interpret;
上面的数据结构比较简单，但是很能说明问题。就拿变量来说吧，这里就可以定义成字母的解释器、数字解释器、下划线解释器三种形式。所以，我们可以进一步定义一下process的相关函数。

[cpp] view plaincopy

#define DIGITAL_TYPE 1
#define LETTER_TYPE 2
#define BOTTOM_LINE 3
void* digital_process(void* pData, int* type, int* result)
{
```
 UINT8* str; 
```

 assert(NULL != pData && NULL != type && NULL != result);

```
str = (UNT8*)pData; 
```
```
while (*str >= '0' && *str <= '9') 
```
```
{ 
```
```
 str ++; 
```
```
} 
```
```
if(*str == '\0') 
```
```
{ 
```
```
 *result = TRUE; 
```
```
 return NULL; 
```
```
} 
```
```
if(*str == '_') 
```
```
{ 
```
```
 *result = TRUE; 
```
```
 *type = BOTTOM_TYPE; 
```
```
 return str; 
```
```
} 
```

if(*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')

```
{ 
```
```
 *result = TRUE; 
```
```
 *type = LETTER_TYPE; 
```
```
 return str; 
```
```
} 
```
```
*result = FALSE; 
```
```
return NULL; 
```
}
void* letter_process(void* pData, int* type, int* result)
{
```
UINT8* str; 
```

assert(NULL != pData && NULL != type && NULL != result);

```
str = (UNT8*)pData; 
```

while (*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')

```
{ 
```
```
 str ++; 
```
```
} 
```
```
if(*str == '\0') 
```
```
{ 
```
```
 *result = TRUE; 
```
```
 return NULL; 
```
```
} 
```
```
if(*str == '_') 
```
```
{ 
```
```
 *result = TRUE; 
```
```
 *type = BOTTOM_TYPE; 
```
```
 return str; 
```
```
} 
```
```
if(*str >= '0' && *str <= '9') 
```
```
{ 
```
```
 *result = TRUE; 
```
```
 *type = DIGITAL_TYPE; 
```
```
 return str; 
```
```
} 
```
```
*result = FALSE; 
```
```
return NULL; 
```
}
void* bottom_process(void* pData, int* type, int* result)
{
```
UINT8* str; 
```

assert(NULL != pData && NULL != type && NULL != result);

```
str = (UNT8*)pData; 
```
```
while ('_' == *str ) 
```
```
{ 
```
```
 str ++; 
```
```
} 
```
```
if(*str == '\0') 
```
```
{ 
```
```
 *result = TRUE; 
```
```
 return NULL; 
```
```
} 
```

if(*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')

```
{ 
```
```
 *result = TRUE; 
```
```
 *type = LETTER_TYPE; 
```
```
 return str; 
```
```
} 
```
```
if(*str >= '0' && *str <= '9') 
```
```
 { 
```
```
 *result = TRUE; 
```
```
 *type = DIGITAL_TYPE; 
```
```
 return str; 
```
```
 } 
```
```
 *result = FALSE; 
```
```
 return NULL; 
```
}

既然是撤销，那么我们在进行某种动作的时候，就应该创建一个相应的撤销操作？这个撤销操作的相关定义可以是这样的。

[cpp] view plaincopy

typedef struct _Action
{
```
 int type; 
```
```
 struct _Action* next; 
```
```
 void* pData; 
```
```
 void (*process)(void* pData); 
```
}Action;
数据结构中定义了两个部分：撤销的数据、恢复的操作。那么这个撤销函数应该有一个创建的函数，还有一个恢复的函数。所以，作为撤销动作的管理者应该包括，
[cpp] view plaincopy
typedef struct _Organizer
{
```
 int number; 
```
```
 Action* pActionHead; 
```
```
 Action* (*create)(); 
```

 void (*restore)(struct _Organizer* pOrganizer);

}Organizer;
既然数据在创建和修改的过程中都会有相应的恢复操作，那么要是真正恢复原来的数据也就变得非常简单了。
[cpp] view plaincopy
void restore(struct _Organizer* pOrganizer)
{
```
 Action* pHead; 
```
```
 assert(NULL != pOrganizer); 
```
```
 pHead = pOrganizer->pActionHead; 
```
```
 pHead->process(pHead->pData); 
```

 pOrganizer->pActionHead = pHead->next;

```
 pOrganizer->number --; 
```
```
free(pHead); 
```
```
return; 
```
}

typedef struct _Object
{

 observer* pObserverList[MAX_BINDING_NUMBER];

```
 int number; 
```

 void (*notify)(struct _Object* pObject);

 void (*add_observer)(observer* pObserver);

 void (*del_observer)(observer* pObserver);

}Object;
其实，我们需要定义的就是观察者本身了。就像我们前面说的一样，观察者可以是菜单、工具栏或者是子窗口等等。
[cpp] view plaincopy
typedef struct _Observer
{
```
 Object* pObject; 
```

 void (*update)(struct _Observer* pObserver);

}Observer;
紧接着，我们要做的就是在Observer创建的时候，把observer自身绑定到Object上面。
[cpp] view plaincopy
void bind_observer_to_object(Observer* pObserver, Object* pObject)
{

 assert(NULL != pObserver && NULL != pObject);

```
 pObserver->pObject = pObject; 
```
```
 pObject->add_observer(pObserver); 
```
}
void unbind_observer_from_object(Observer* pObserver, Object* pObject)
{

assert(NULL != pObserver && NULL != pObject);

pObject->del_observer(observer* pObserver);

memset(pObserver, 0, sizeof(Observer));

}
既然Observer在创建的时候就把自己绑定在某一个具体的Object上面，那么Object发生改变的时候，统一更新操作就是一件很容易的事情了。
[cpp] view plaincopy
void notify(struct _Object* pObject)
{
```
 Obserer* pObserver; 
```
```
 int index; 
```
```
 assert(NULL != pObject); 
```

 for(index = 0; index < pObject->number; index++)

```
 { 
```

 pObserver = pObjecet->pObserverList[index];

```
 pObserver->update(pObserver); 
```
```
} 
```
}

typedef struct _MeatDumpling
{
```
 void (*make)(); 
```
}MeatDumpling;
typedef struct _NormalDumpling
{
```
 void (*make)(); 
```
}NormalDumpling;
上面只是对饺子进行归类。第一类是对肉馅饺子的归类，第二类是对素馅饺子的归类，这些地方都没有什么特别之处。那么，关键是我们怎么把它和顾客的要求联系在一起呢？
[cpp] view plaincopy
typedef struct _DumplingReuqest
{
```
 int type; 
```
```
 void* pDumpling; 
```
}DumplingRequest;
这里定义了一个饺子买卖的接口。它的特别支持就在于两个地方，第一是我们定义了饺子的类型type，这个type是可以随便扩充的；第二就是这里的pDumpling是一个void*指针，只有把它和具体的dumpling绑定才会衍生出具体的含义。
[cpp] view plaincopy
void buy_dumpling(DumplingReuqest* pDumplingRequest)
{
```
 assert(NULL != pDumplingRequest); 
```

 if(MEAT_TYPE == pDumplingRequest->type)

 return (MeatDumpling*)(pDumplingRequest->pDumpling)->make();

```
 else 
```

 return (NormalDumpling*)(pDumplingRequest->pDumpling)->make();

}

typedef struct _AssemblePersonalComputer
{
```
 void (*assemble_cpu)(); 
```
```
 void (*assemble_memory)(); 
```
```
 void (*assemble_harddisk)(); 
```
}AssemblePersonalComputer;
对于一个希望配置intel cpu，samsung 内存、日立硬盘的朋友。他可以这么设计，
[cpp] view plaincopy
void assemble_intel_cpu()
{
```
 printf("intel cpu!\n"); 
```
}
void assemble_samsung_memory()
{
```
 printf("samsung memory!\n"); 
```
}
void assemble_hitachi_harddisk()
{
```
printf("hitachi harddisk!\n"); 
```
}
而对于一个希望配置AMD cpu, kingston内存、西部数据硬盘的朋友。他又该怎么做呢？
[cpp] view plaincopy
void assemble_amd_cpu()
{
```
 printf("amd cpu!\n"); 
```
}
void assemble_kingston_memory()
{
```
 printf("kingston memory!\n"); 
```
}
void assmeble_western_digital_harddisk()
{
```
printf("western digital harddisk!\n"); 
```
}

十、 C语言和设计模式（中介者模式）

typedef struct _Mediator
{
```
 People* man; 
```
```
 People* woman; 
```
}Mediator;
上面的数据结构是给媒婆的，那么当然还有一个数据结构是给男方、女方的。
[cpp] view plaincopy
typedef struct _People
{
```
 Mediator* pMediator; 
```

 void (*request)(struct _People* pPeople);

 void (*process)(struct _Peoplle* pPeople);

}People;
所以，这里我们看到的如果是男方的要求，那么这个要求应该女方去处理啊，怎么处理呢？
[cpp] view plaincopy
void man_request(struct _People* pPeople)
{
```
 assert(NULL != pPeople); 
```

 pPeople->pMediator->woman->process(pPeople->pMediator->woman);

}
上面做的是男方向女方提出的要求，所以女方也可以向男方提要求了。毕竟男女平等嘛。
[cpp] view plaincopy
void woman_request(struct _People* pPeople)
{
```
 assert(NULL != pPeople); 
```

 pPeople->pMediator->man->process(pPeople->pMediator->man);

}

typedef struct _MoviePlay
{

 struct _CommMoviePlay* pCommMoviePlay;

}MoviePlay;
typedef struct _CommMoviePlay
{
```
 HANDLE hFile; 
```
```
void (*play)(HANDLE hFile); 
```
}CommMoviePlay;
这个时候呢，对于用户来说，统一的文件接口就是MoviePlay。接下来的一个工作，就是编写一个统一的访问接口。
[cpp] view plaincopy
void play_movie_file(struct MoviePlay* pMoviePlay)
{
```
 CommMoviePlay* pCommMoviePlay; 
```
```
 assert(NULL != pMoviePlay); 
```

 pCommMoviePlay = pMoviePlay->pCommMoviePlay;

 pCommMoviePlay->play(pCommMoviePlay->hFile);

}
最后的工作就是对不同的hFile进行play的实际操作，写简单一点就是，
[cpp] view plaincopy
void play_avi_file(HANDLE hFile)
{
```
 printf("play avi file!\n"); 
```
}
void play_rmvb_file(HANDLE hFile)
{
```
 printf("play rmvb file!\n"); 
```
}
void play_mpeg_file(HANDLE hFile)
{
```
printf("play mpeg file!\n"); 
```
}

class voltage_12v
{
public:
```
 voltage_12v() {} 
```
```
 virtual ~voltage_12v() {} 
```
```
 virtual void request() {} 
```
};
class v220_to_v12
{
public:
```
v220_to_v12() {} 
```
```
~v220_to_v12() {} 
```
```
void voltage_transform_process() {} 
```
};
class adapter: public voltage_12v
{
```
v220_to_v12* pAdaptee; 
```
public:
```
adapter() {} 
```
```
~adapter() {} 
```
```
void request() 
```
```
{ 
```

 pAdaptee->voltage_transform_process();

```
} 
```
};
通过上面的代码，我们其实可以这样理解。类voltage_12v表示我们的最终目的就是为了获得一个12v的直流电压。当然获得12v可以有很多的方法，利用适配器转换仅仅是其中的一个方法。adapter表示适配器，它自己不能实现220v到12v的转换工作，所以需要调用类v220_to_v12的转换函数。所以，我们利用adapter获得12v的过程，其实就是调用v220_to_v12函数的过程。
不过，既然我们的主题是用c语言来编写适配器模式，那么我们就要实现最初的目标。这其实也不难，关键一步就是定义一个Adapter的数据结构。然后把所有的Adapter工作都由Adaptee来做，就是这么简单。不知我说明白了没有？
[cpp] view plaincopy
typdef struct _Adaptee
{

 void (*real_process)(struct _Adaptee* pAdaptee);

}Adaptee;
typedef struct _Adapter
{
```
 void* pAdaptee; 
```

 void (*transform_process)(struct _Adapter* pAdapter);

}Adapter;

typedef struct _Object
{
```
 struct _Object* prev; 
```

 void (*decorate)(struct _Object* pObject);

}Object;
装饰模式最经典的地方就是把pObject这个值放在了数据结构里面。当然，装饰模式的奥妙还不仅仅在这个地方，还有一个地方就是迭代处理。我们可以自己随便写一个decorate函数试试看，
[cpp] view plaincopy
void decorate(struct _Object* pObeject)
{
```
 assert(NULL != pObject); 
```
```
 if(NULL != pObject->prev) 
```

 pObject->prev->decorate(pObject->prev);

```
 printf("normal decorate!\n"); 
```
}
所以，装饰模式的最重要的两个方面就体现在：prev参数和decorate迭代处理。
十四、 C语言和设计模式（享元模式）
享元模式看上去有点玄乎，但是其实也没有那么复杂。我们还是用示例说话。比如说，大家在使用电脑的使用应该少不了使用WORD软件。使用WORD呢，那就少不了设置模板。什么模板呢，比如说标题的模板，正文的模板等等。这些模板呢，又包括很多的内容。哪些方面呢，比如说字体、标号、字距、行距、大小等等。
[cpp] view plaincopy
typedef struct _Font
{
```
 int type; 
```
```
 int sequence; 
```
```
 int gap; 
```
```
 int lineDistance; 
```
```
 void (*operate)(struct _Font* pFont); 
```
}Font;
上面的Font表示了各种Font的模板形式。所以，下面的方法就是定制一个FontFactory的结构。
[cpp] view plaincopy
typedef struct _FontFactory
{
```
 Font ppFont; 
```
```
 int number; 
```
```
 int size; 
```

 Font* GetFont(struct _FontFactory* pFontFactory, int type, int sequence, int gap, int lineDistance);

}FontFactory;
这里的GetFont即使对当前的Font进行判断，如果Font存在，那么返回；否则创建一个新的Font模式。
[cpp] view plaincopy
Font* GetFont(struct _FontFactory* pFontFactory, int type, int sequence, int gap, int lineDistance)
{
```
 int index; 
```
```
 Font* pFont; 
```
```
 Font* ppFont; 
```
```
 if(NULL == pFontFactory) 
```
```
 return NULL; 
```

for(index = 0; index < pFontFactory->number; index++)

```
{ 
```

 if(type != pFontFactory->ppFont[index]->type)

```
 continue; 
```

 if(sequence != pFontFactory->ppFont[index]->sequence)

```
 continue; 
```

 if(gap != pFontFactory->ppFont[index]->gap)

```
 continue; 
```

 if(lineDistance != pFontFactory->ppFont[index]->lineDistance)

```
 continue; 
```
```
 return pFontFactory->ppFont[index]; 
```
```
} 
```
```
pFont = (Font*)malloc(sizeof(Font)); 
```
```
assert(NULL != pFont); 
```
```
pFont->type = type; 
```
```
pFont->sequence = sequence; 
```
```
pFont->gap = gap; 
```
```
pFont->lineDistance = lineDistance; 
```

if(pFontFactory-> number < pFontFactory->size)

```
{ 
```
```
 pFontFactory->ppFont[index] = pFont; 
```
```
 pFontFactory->number ++; 
```
```
 return pFont; 
```
```
} 
```

ppFont = (Font)malloc(sizeof(Font*) * pFontFactory->size * 2);

```
assert(NULL != ppFont); 
```

memmove(ppFont, pFontFacoty->ppFont, pFontFactory->size);

```
free(pFontFactory->ppFont); 
```
```
pFontFactory->size *= 2; 
```
```
pFontFactory->number ++; 
```
```
ppFontFactory->ppFont = ppFont; 
```
```
return pFont; 
```
}

typedef struct _PC_Client
{
```
 void (*request)(); 
```
}PC_Client;
void ftp_request()
{
```
 printf("request from ftp!\n"); 
```
}
void http_request()
{
```
printf("request from http!\n"); 
```
}
void smtp_request()
{
```
printf("request from smtp!\n"); 
```
}
这个时候，代理的操作应该怎么写呢？怎么处理来自各个协议的请求呢？
[cpp] view plaincopy
typedef struct _Proxy
{
```
 PC_Client* pClient; 
```
}Proxy;
void process(Proxy* pProxy)
{
```
 assert(NULL != pProxy); 
```
```
pProxy->pClient->request(); 
```
}

typedef struct _FoodSteet
{
```
 void (*eat)(); 
```
}FoodStreet;
void eat()
{
```
 printf("eat here!\n"); 
```
}
typedef struct _ShopStreet
{
```
void (*buy)(); 
```
}ShopStreet;
void buy()
{
```
printf("buy here!\n"); 
```
}
typedef struct _BookStreet
{
```
void (*read)(); 
```
}BookStreet;
void read()
{
```
printf("read here"); 
```
}
下面，我们就要在一个plaza里面完成所有的项目，怎么办呢？
[cpp] view plaincopy
typedef struct _Plaza
{
```
 FoodStreet* pFoodStreet; 
```
```
 ShopStreet* pShopStreet; 
```
```
 BookStreet* pBookStreet; 
```
```
 void (*play)(struct _Plaza* pPlaza); 
```
}Plaza;
void play(struct _Plaza* pPlaza)
{
```
assert(NULL != pPlaza); 
```
```
pPlaza->pFoodStreet->eat(); 
```
```
pPlaza->pShopStreet->buy(); 
```
```
pPlaza->pBookStreet->read(); 
```
}

typedef struct _Container
{
```
 int* pData; 
```
```
 int size; 
```
```
 int length; 
```

 Interator* (*create_new_interator)(struct _Container* pContainer);

 int (*get_first)(struct _Container* pContainer);

 int (*get_last)(struct _Container* pContainer);

}Container;
我们看到，容器可以创建迭代器。那什么是迭代器呢？
[cpp] view plaincopy
typedef struct _Interator
{
```
 void* pVector; 
```
```
 int index; 
```

 int(* get_first)(struct _Interator* pInterator);

 int(* get_last)(struct _Interator* pInterator);

}Interator;
我们看到，容器有get_first，迭代器也有get_first，这中间有什么区别？
[cpp] view plaincopy
int vector_get_first(struct _Container* pContainer)
{
```
 assert(NULL != pContainer); 
```
```
 return pContainer->pData[0]; 
```
}
int vector_get_last(struct _Container* pContainer)
{
```
assert(NULL != pContainer); 
```

return pContainer->pData[pContainer->size -1];

}
int vector_interator_get_first(struct _Interator* pInterator)
{
```
Container* pContainer; 
```

assert(NULL != pInterator && NULL != pInterator->pVector);

pContainer = (struct _Container*) (pInterator->pVector);

return pContainer ->get_first(pContainer);

}
int vector_interator_get_last(struct _Interator* pInterator)
{
```
Container* pContainer; 
```

assert(NULL != pInterator && NULL != pInterator->pVector);

pContainer = (struct _Container*) (pInterator->pVector);

return pContainer ->get_last(pContainer);

}
看到上面的代码之后，我们发现迭代器的操作实际上也是对容器的操作而已。

typedef struct _Apple
{
```
 void (*print_apple)(); 
```
}Apple;
typedef struct _Grape
{
```
 void (*print_grape)(); 
```
}Grape;
上面分别对苹果和葡萄进行了抽象，当然它们的具体函数也是不一样的。
[cpp] view plaincopy
void print_white_apple()
{
```
 printf("white apple!\n"); 
```
}
void print_red_apple()
{
```
 printf("red apple!\n"); 
```
}
void print_white_grape()
{
```
printf("white grape!\n"); 
```
}
void print_red_grape()
{
```
printf("red grape!\n"); 
```
}
完成了水果函数的定义。下面就该定义工厂了，和水果一样，我们也需要对工厂进行抽象处理。
[cpp] view plaincopy
typedef struct _FruitShop
{
```
 Apple* (*sell_apple)(); 
```
```
 Apple* (*sell_grape)(); 
```
}FruitShop;
所以，对于卖白苹果、白葡萄的水果店就该这样设计了，红苹果、红葡萄的水果店亦是如此。
[cpp] view plaincopy
Apple* sell_white_apple()
{

 Apple* pApple = (Apple*) malloc(sizeof(Apple));

```
 assert(NULL != pApple); 
```

 pApple->print_apple = print_white_apple;

```
 return pApple; 
```
}
Grape* sell_white_grape()
{

Grape* pGrape = (Grape*) malloc(sizeof(Grape));

```
assert(NULL != pGrape); 
```

pGrape->print_grape = print_white_grape;

```
return pGrape; 
```
}
这样，基本的框架就算搭建完成的，以后创建工厂的时候，
[cpp] view plaincopy
FruitShop* create_fruit_shop(int color)
{

 FruitShop* pFruitShop = (FruitShop*) malloc(sizeof(FruitShop));

```
 assert(NULL != pFruitShop); 
```
```
 if(WHITE == color) 
```
```
 { 
```

 pFruitShop->sell_apple = sell_white_apple;

 pFruitShop->sell_grape = sell_white_grape;

```
} 
```
```
else 
```
```
{ 
```

 pFruitShop->sell_apple = sell_red_apple;

 pFruitShop->sell_grape = sell_red_grape;

```
} 
```
```
return pFruitShop; 
```
}

typedef struct _Leader
{
```
 struct _Leader* next; 
```
```
 int account; 
```

 int (*request)(strcut _Leader* pLeader, int num);

}Leader;
所以这个时候，我们首先需要设置额度和领导。

[cpp] view plaincopy

void set_account(struct _Leader* pLeader, int account)
{
```
 assert(NULL != pLeader); 
```
```
 pLeader->account = account; 
```
```
 return; 
```
}
void set_next_leader(const struct _Leader* pLeader, struct _Leader* next)
{

assert(NULL != pLeader && NULL != next);

```
pLeader->next = next; 
```
```
return; 
```
}
此时，如果有一个员工过来报销费用，那么应该怎么做呢？假设此时的Leader是经理，报销额度是10万元。所以此时，我们可以看看报销的费用是不是小于10万元？少于这个数就OK，反之就得上报自己的领导了。
[cpp] view plaincopy
int request_for_manager(struct _Leader* pLeader, int num)
{
```
 assert(NULL != pLeader && 0 != num); 
```
```
 if(num < ) 
```
```
 return 1; 
```
```
 else if(pLeader->next) 
```

 return pLeader->next->request(pLeader->next, num);

```
 else 
```
```
 return 0; 
```
}

typedef struct _Shoe
{
```
 int type; 
```
```
 void (*print_shoe)(struct _Shoe*); 
```
}Shoe;
就像上面说的，现在有胶鞋，那也有皮鞋，我们该怎么做呢？
[cpp] view plaincopy
void print_leather_shoe(struct _Shoe* pShoe)
{
```
 assert(NULL != pShoe); 
```
```
 printf("This is a leather show!\n"); 
```
}
void print_rubber_shoe(struct _Shoe* pShoe)
{
```
 assert(NULL != pShoe); 
```
```
printf("This is a rubber shoe!\n"); 
```
}
所以，对于一个工厂来说，创建什么样的鞋子，就看我们输入的参数是什么？至于结果，那都是一样的。
[cpp] view plaincopy
#define LEATHER_TYPE 0x01
#define RUBBER_TYPE 0x02
Shoe* manufacture_new_shoe(int type)
{

 assert(LEATHER_TYPE == type || RUBBER_TYPE == type);

 Shoe* pShoe = (Shoe*)malloc(sizeof(Shoe));

```
 assert(NULL != pShoe); 
```
```
memset(pShoe, 0, sizeof(Shoe)); 
```
```
if(LEATHER_TYPE == type) 
```
```
{ 
```
```
 pShoe->type == LEATHER_TYPE; 
```

 pShoe->print_shoe = print_leather_shoe;

```
} 
```
```
else 
```
```
{ 
```
```
 pShoe->type == RUBBER_TYPE; 
```

 pShoe->print_shoe = print_rubber_shoe;

```
} 
```
```
return pShoe; 
```
}

template
int compare (type a, type b)
{
```
 return a > b ? 1 : 0; 
```
}
模板函数提示我们，只要比较的逻辑是确定的，那么不管是什么数据类型，都会得到一个相应的结果。固然，这个比较的流程比较简单，即使没有采用模板函数也没有关系。但是，要是需要拆分的步骤很多，那么又该怎么办呢？如果相通了这个问题，那么也就明白了什么是template模式。
比方说，现在我们需要设计一个流程。这个流程有很多小的步骤完成。然而，其中每一个步骤的方法是多种多样的，我们可以很多选择。但是，所有步骤构成的逻辑是唯一的，那么我们该怎么办呢？其实也简单。那就是在基类中除了流程函数外，其他的步骤函数全部设置为virtual函数即可。
[cpp] view plaincopy
class basic
{
public:
```
 void basic() {} 
```
```
 virtual ~basic() {} 
```
```
 virtual void step1() {} 
```
```
 virtual void step2() {} 
```
```
 void process() 
```
```
 { 
```
```
 step1(); 
```
```
 step2(); 
```
```
} 
```
};
basic的类说明了基本的流程process是唯一的，所以我们要做的就是对step1和step2进行改写。
[cpp] view plaincopy
class data_A : public basic
{
public:
```
 data_A() {} 
```
```
 ~data_A() {} 
```
```
 void step1() 
```
```
 { 
```
```
 printf("step 1 in data_A!\n"); 
```
```
 } 
```
```
void step2() 
```
```
{ 
```
```
 printf("step 2 in data_A!\n"); 
```
```
} 
```
};
所以，按照我个人的理解，这里的template主要是一种流程上的统一，细节实现上的分离。明白了这个思想，那么用C语言来描述template模式就不是什么难事了。
[cpp] view plaincopy
typedef struct _Basic
{
```
 void* pData; 
```

 void (*step1) (struct _Basic* pBasic);

 void (*step2) (struct _Basic* pBasic);

 void (*process) (struct _Basic* pBasic);

}Basic;
因为在C++中process函数是直接继承的，C语言下面没有这个机制。所以，对于每一个process来说，process函数都是唯一的，但是我们每一次操作的时候还是要去复制一遍函数指针。而step1和step2是不同的，所以各种方法可以用来灵活修改自己的处理逻辑，没有问题。
[cpp] view plaincopy
void process(struct _Basic* pBasic)
{
```
 pBasic->step1(pBasic); 
```
```
 pBasic->step2(pBasic); 
```
}

typedef struct _NODE
{
```
 void* pData; 
```
```
 struct _NODE* left; 
```
```
 struct _NODE* right; 
```
}NODE;
那什么时候是叶子节点，其实就是left、right为NULL的时候。那么如果它们不是NULL呢，那么很明显此时它们已经是父节点了。那么，我们的这个组合模式是怎么一个情况呢？
[cpp] view plaincopy
typedef struct _Object
{
```
 struct _Object ppObject; 
```
```
 int number; 
```

 void (*operate)(struct _Object* pObject);

}Object;
就是这么一个简单的数据结构，是怎么实现子节点和父节点的差别呢。比如说，现在我们需要对一个父节点的operate进行操作，此时的operate函数应该怎么操作呢？
[cpp] view plaincopy
void operate_of_parent(struct _Object* pObject)
{
```
 int index; 
```
```
 assert(NULL != pObject); 
```

 assert(NULL != pObject->ppObject && 0 != pObject->number);

 for(index = 0; index < pObject->number; index ++)

```
 { 
```

 pObject->ppObject[index]->operate(pObject->ppObject[index]);

```
} 
```
}
当然，有了parent的operate，也有child的operate。至于是什么操作，那就看自己是怎么操作的了。

[cpp] view plaincopy

void operate_of_child(struct _Object* pObject)
{
```
 assert(NULL != pObject); 
```
```
 printf("child node!\n"); 
```
}
父节点也好，子节点也罢，一切的一切都是最后的应用。其实，用户的调用也非常简单，就这么一个简单的函数。

[cpp] view plaincopy

void process(struct Object* pObject)
{
```
 assert(NULL != pObject); 
```
```
 pObject->operate(pObject); 
```
}

class data
{
public:
```
 data () {} 
```
```
 virtual ~data() {} 
```
```
 virtual class data* copy() = 0; 
```
};
class data_A : public data
{
public:
```
data_A() {} 
```
```
~data_A() {} 
```
```
class data* copy() 
```
```
{ 
```
```
 return new data_A(); 
```
```
} 
```
};
class data_B : public data
{
public:
```
data_B() {} 
```
```
~data_B() {} 
```
```
class data* copy() 
```
```
{ 
```
```
 return new data_B(); 
```
```
} 
```
};
那怎么使用呢？其实只要一个通用的调用接口就可以了。
[cpp] view plaincopy
class data* clone(class data* pData)
{
```
 return pData->copy(); 
```
}
就这么简单的一个技巧，对C来说，当然也不是什么难事。
[cpp] view plaincopy
typedef struct _DATA
{

 struct _DATA* (*copy) (struct _DATA* pData);

}DATA;
假设也有这么一个类型data_A,
[cpp] view plaincopy
DATA data_A = {data_copy_A};
既然上面用到了这个函数，所以我们也要定义啊。
[cpp] view plaincopy
struct _DATA* data_copy_A(struct _DATA* pData)
{

 DATA* pResult = (DATA*)malloc(sizeof(DATA));

```
 assert(NULL != pResult); 
```

 memmove(pResult, pData, sizeof(DATA));

```
 return pResult; 
```
};
使用上呢，当然也不含糊。
[cpp] view plaincopy
struct _DATA* clone(struct _DATA* pData)
{
```
 return pData->copy(pData); 
```
};

#include <string.h>
#include <assert.h>
class object
{
public:
```
 static class object* pObject; 
```
```
 static object* create_new_object() 
```
```
{ 
```
```
 if(NULL != pObject) 
```
```
 return pObject; 
```
```
 pObject = new object(); 
```
```
 assert(NULL != pObject); 
```
```
 return pObject; 
```
```
} 
```
private:
```
object() {} 
```
```
~object() {} 
```
};
class object* object::pObject = NULL;
单件模式的技巧就在于类的构造函数是一个私有的函数。但是类的构造函数又是必须创建的？怎么办呢？那就只有动用static函数了。我们看到static里面调用了构造函数，就是这么简单。
[cpp] view plaincopy
int main(int argc, char* argv[])
{

 object* pGlobal = object::create_new_object();

```
 return 1; 
```
}
上面说了C++语言的编写方法，那C语言怎么写？其实也简单。大家也可以试一试。
[cpp] view plaincopy
typedef struct _DATA
{
```
 void* pData; 
```
}DATA;
void* get_data()
{
```
 static DATA* pData = NULL; 
```
```
if(NULL != pData) 
```
```
 return pData; 
```
```
pData = (DATA*)malloc(sizeof(DATA)); 
```
```
assert(NULL != pData); 
```
```
return (void*)pData; 
```
}

其实，就我个人看来，不管什么方法都离不开人。一个人写不出二叉树，你怎么让他写？敏捷吗？你写一行，我写一行。还是迭代？写三行，删掉两行，再写三行。项目的成功是偶然的，但是项目的失败却有很多原因，管理混乱、需求混乱、设计低劣、代码质量差、测试不到位等等。就软件企业而言，没有比优秀的文化和出色的企业人才更重要的了。 从软件设计层面来说，一般来说主要包括三个方面： （1）软件的设计受众，是小孩子、老人、女性，还是专业人士等等； （2）软件的基本设计原则，以人为本、模块分离、层次清晰、简约至上、适用为先、抽象基本业务等等； （3）软件编写模式，比如装饰模式、责任链、单件模式等等。 从某种意义上说，设计思想构成了软件的主题。软件原则是我们在开发中的必须遵循的准绳。软件编写模式是开发过程中的重要经验总结。灵活运用设计模式，一方面利于我们编写高质量的代码，另一方面也方便我们对代码进行维护。毕竟对于广大的软件开发者来说，软件的维护时间要比软件编写的时间要多得多。编写过程中，难免要有新的需求，要和别的模块打交道，要对已有的代码进行复用，那么这时候设计模式就派上了用场。我们讨论的主题其实就是设计模式。 讲到设计模式，人们首先想到的语言就是c#或者是java，最不济也是c++，一般来说没有人会考虑到c语言。其实，我认为设计模式就是一种基本思想，过度美化或者神化其实没有必要。其实阅读过linux kernel的朋友都知道，linux虽然自身支持很多的文件系统，但是linux自身很好地把这些系统的基本操作都抽象出来了，成为了基本的虚拟文件系统。 举个例子来说，现在让你写一个音乐播放器，但是要支持的文件格式很多，什么ogg，wav，mp3啊，统统要支持。这时候，你会怎么编写呢？如果用C++语言，你可能会这么写。

[cpp] view plaincopy

class music_file
{
```
 HANDLE hFile; 
```
public:
```
 void music_file() {} 
```
```
 virtual ~music_file() {} 
```
```
 virtual void read_file() {} 
```
```
 virtual void play() {} 
```
```
virtual void stop() {} 
```
```
virtual void back() {} 
```
```
virtual void front() {} 
```
```
virtual void up() {} 
```
```
virtual void down() {} 
```
};
其实，你想想看，如果用C语言能够完成相同的抽象操作，那不是效果一样的吗？

[cpp] view plaincopy

typedef struct _music_file
{
```
 HANDLE hFile; 
```

 void (*read_file)(struct _music_file* pMusicFile);

 void (*play)(struct _music_file* pMusicFile);

 void (*stop)(struct _music_file* pMusicFile);

 void (*back)(struct _music_file* pMusicFile);

 void (*front)(struct _music_file* pMusicFile);

 void (*down)(struct _music_file* pMusicFile);

void (*up)(struct _music_file* pMusicFile);

}music_file;
当然，上面的例子比较简单，但是也能说明一些问题。写这篇文章的目的一是希望和朋友们共同学习模式的相关内容，另一方面也希望朋友们能够活学活用，既不要迷信权威，也不要妄自菲薄。只要付出努力，付出汗水，肯定会有收获的。有些大环境你改变不了，那就从改变自己开始。万丈高楼平地起，一步一个脚印才能真真实实学到东西。如果盲目崇拜，言必google、微软、apple，那么除了带来几个唾沫星，还能有什么受用呢？无非白费了口舌而已。

希望和大家共勉。

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://haidsoft.com/116899.html

【 C语言 】 C语言设计模式

相关推荐

发表回复

【 C语言】 C语言设计模式