引言
设计模式是软件工程中的一种最佳实践，它可以帮助开发者解决在软件设计过程中遇到的问题。C语言作为一种历史悠久且功能强大的编程语言，同样适用设计模式。本文将揭秘C语言中的23种经典设计模式，并通过实战解析和应用技巧，帮助开发者更好地理解和运用这些设计模式。
1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。
typedef struct {
int value;
} Singleton;
Singleton* GetSingleton() {
static Singleton instance;
return &instance;
}
2. 工厂模式（Factory Method）
工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。
typedef struct {
void (*Create)(void*);
} Creator;
void ConcreteCreator1_Create(void* v) {
// 创建具体产品1
}
void ConcreteCreator2_Create(void* v) {
// 创建具体产品2
}
Creator creators[] = {
{ConcreteCreator1_Create},
{ConcreteCreator2_Create}
};
3. 建造者模式（Builder）
建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
typedef struct {
int partA;
int partB;
} Product;
typedef struct {
Product* product;
} Builder;
void Builder_BuildPartA(Builder* b) {
b->product->partA = 1;
}
void Builder_BuildPartB(Builder* b) {
b->product->partB = 2;
}
4. 原型模式（Prototype）
原型模式通过复制现有的实例来创建新的实例。
typedef struct {
int value;
} Prototype;
Prototype* Clone(Prototype* original) {
return (Prototype*)memcpy(malloc(sizeof(Prototype)), original, sizeof(Prototype));
}
5. 适配器模式（Adapter）
适配器模式允许将一个类的接口转换成客户期望的另一个接口。
typedef struct {
void (*DoSomething)(void);
} Adaptee;
typedef struct {
Adaptee* adaptee;
} Adapter;
void Adapter_DoSomething(Adapter* a) {
a->adaptee->DoSomething();
}
6. 桥接模式（Bridge）
桥接模式将抽象部分与实现部分分离，使它们都可以独立地变化。
typedef struct {
void (*Operation)(void);
} Abstraction;
typedef struct {
void (*OperationImp)(void);
} RefinedAbstraction;
typedef struct {
Abstraction* abstraction;
RefinedAbstraction* refinedAbstraction;
} Bridge;
7. 组合模式（Composite）
组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。
typedef struct {
void (*Operation)(void);
} Leaf;
typedef struct {
void (*Operation)(void);
struct _Composite* child;
} Composite;
8. 装饰者模式（Decorator）
装饰者模式动态地给一个对象添加一些额外的职责。
typedef struct {
void (*Operation)(void);
} Component;
typedef struct {
Component* component;
} Decorator;
void Decorator_Operation(Decorator* d) {
d->component->Operation();
}
9. 外观模式（Facade）
外观模式提供一个统一的接口，用来访问子系统中的一群接口。
typedef struct {
void (*Method1)(void);
void (*Method2)(void);
} Subsystem1;
typedef struct {
void (*Method1)(void);
void (*Method2)(void);
} Subsystem2;
typedef struct {
Subsystem1* subsystem1;
Subsystem2* subsystem2;
} Facade;
10. 享元模式（Flyweight）
享元模式通过共享尽可能多的相似对象来减少内存使用。
typedef struct {
int value;
} Flyweight;
typedef struct {
Flyweight* flyweight;
} Context;
11. 代理模式（Proxy）
代理模式为其他对象提供一个代理以控制对这个对象的访问。
typedef struct {
void (*Operation)(void);
} Subject;
typedef struct {
Subject* subject;
} Proxy;
void Proxy_Operation(Proxy* p) {
p->subject->Operation();
}
12. 门面模式（Facade）
门面模式与外观模式类似，都是提供一个统一的接口。
typedef struct {
void (*Method1)(void);
void (*Method2)(void);
} Subsystem1;
typedef struct {
void (*Method1)(void);
void (*Method2)(void);
} Subsystem2;
typedef struct {
Subsystem1* subsystem1;
Subsystem2* subsystem2;
} Facade;
13. 模板方法模式（Template Method）
模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
typedef struct {
void (*Step1)(void);
void (*Step2)(void);
void (*Step3)(void);
} Template;
void Template_Step1(Template* t) {
t->Step1();
}
void Template_Step2(Template* t) {
t->Step2();
}
void Template_Step3(Template* t) {
t->Step3();
}
14. 策略模式（Strategy）
策略模式定义一系列的算法，把它们一个个封装起来，并使它们可以互相替换。
typedef struct {
void (*Algorithm)(void);
} Strategy;
void ConcreteStrategyA_Algorithm(void) {
// 实现算法A
}
void ConcreteStrategyB_Algorithm(void) {
// 实现算法B
}
15. 观察者模式（Observer）
观察者模式定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知。
typedef struct {
void (*Update)(void);
} Subject;
typedef struct {
Subject* subject;
} Observer;
void Observer_Update(Observer* o) {
o->subject->Update();
}
16. 状态模式（State）
状态模式允许对象在其内部状态改变时改变其行为。
typedef struct {
void (*Handle)(void);
} State;
typedef struct {
State* state;
} Context;
void State_Handle(State* s) {
s->Handle();
}
17. 访问者模式（Visitor）
访问者模式表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
typedef struct {
void (*Visit)(void);
} Element;
typedef struct {
void (*VisitElement)(Element* e);
} Visitor;
void Visitor_VisitElement(Visitor* v, Element* e) {
v->VisitElement(e);
}
18. 中介者模式（Mediator）
中介者模式定义一个对象来封装一组对象之间的交互，从而使它们不必直接交互。
typedef struct {
void (*Communicate)(void);
} Mediator;
typedef struct {
Mediator* mediator;
} Colleague;
void Colleague_Comunicate(Colleague* c) {
c->mediator->Communicate();
}
19. 迭代器模式（Iterator）
迭代器模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
typedef struct {
void (*First)(void);
void (*Next)(void);
int (*IsDone)(void);
void (*CurrentItem)(void);
} Iterator;
typedef struct {
Iterator* iterator;
} Aggregate;
void Aggregate_First(Aggregate* a) {
a->iterator->First();
}
void Aggregate_Next(Aggregate* a) {
a->iterator->Next();
}
int Aggregate_IsDone(Aggregate* a) {
return a->iterator->IsDone();
}
void Aggregate_CurrentItem(Aggregate* a) {
a->iterator->CurrentItem();
}
20. 命令模式（Command）
命令模式将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，以及支持可撤销的操作。
typedef struct {
void (*Execute)(void);
} Command;
typedef struct {
Command* command;
} Invoker;
void Invoker_Execute(Invoker* i) {
i->command->Execute();
}
21. 职责链模式（Chain of Responsibility）
职责链模式使多个对象都有机会处理请求，从而避免请求发送者和接收者之间的耦合关系。
typedef struct {
void (*HandleRequest)(void);
} Handler;
typedef struct {
Handler* handler;
} Chain;
void Handler_HandleRequest(Handler* h) {
h->handler->HandleRequest();
}
22. 模板命令模式（Template Command）
模板命令模式是命令模式的扩展，它允许定义一个操作序列，并使这些操作可以在运行时动态地组合。
typedef struct {
void (*Execute)(void);
} Command;
typedef struct {
Command* command;
} Invoker;
void Invoker_Execute(Invoker* i) {
i->command->Execute();
}
23. 备忘录模式（Memento）
备忘录模式在不暴露对象内部细节的情况下保存和恢复对象之前的状态。
typedef struct {
void (*Save)(void);
void (*Restore)(void);
} Memento;
typedef struct {
Memento* memento;
} Originator;
void Originator_Save(Originator* o) {
o->memento->Save();
}
void Originator_Restore(Originator* o) {
o->memento->Restore();
}
总结
本文介绍了C语言中的23种经典设计模式，并通过实战解析和应用技巧，帮助开发者更好地理解和运用这些设计模式。在实际开发过程中，选择合适的设计模式可以提高代码的可读性、可维护性和可扩展性。希望本文能对您的软件开发工作有所帮助。