【设计模式】我对设计模式的C语言解读
这个文章的目的
我很早就知道有一个可以学设计模式的网站
一个乌克兰老哥搞得学设计模式的网站，还有爱好者直接翻译成中文的页面~
我一直没能有机会学一学~
每一种设计模式都有一个很生动的图解，还有对应的代码实现，其中也有C++等等常见的面向对象语言的实现
例如:
我学这些设计模式(C++实现)的时候，我在想一件很有意思的事情
如果用C语言来写会怎么样呢？
因为C++和C语言还是有些共同之处的吧
如果同样的设计模式，能不能用C语言来解读，或者说能不能用C语言来实现呢
于是乎，我就来尝试用C语言（编译环境基于VS 2022）模拟出它提供的例程中C++的那种行为来，于是乎有了这个文章
目录
- 工厂方法
- 抽象工厂方法
- 生成器
工厂方法
工厂方法的介绍: https://refactoringguru.cn/design-patterns/factory-method
工厂方法的C++实现: https://refactoringguru.cn/design-patterns/factory-method/cpp/example
我的理解就是
不同的"工厂"生产不同的"产品"
不同的“产品”可以做不同的"事"
不同的"工厂"都有一个统一的基类(我叫它抽象工厂类)，它都能生产"产品"
不同的"产品"都有一个统一的基类(我叫它抽象产品类)，它都能做"事"
如果用一个图(直白的图，不是UML图)来说，大概就是这样
通过这张图
可以知道产品和工厂都存在一个抽象到具体的过程~
在C++里面，这个天然就可以通过子父类的继承来实现，这没啥好说的~
任何产品和任何工厂都有各自统一的行为，产品可以做某种事情，工厂可以生产某种产品，做事和生产是一个抽象的接口
在C++里面，这个是通过子类去实现或者说重写了父类的方法来实现的。
那么重点来了，当切换成C语言
继承，我的理解可以通过"结构体层层套娃"来实现
方法重写，我的理解可以通过"函数指针"来实现
下面就是我模仿网站上C++实现，转换成C语言实现的工厂方法
#include
#include
#include ///
/// 抽象产品
///
typedef struct
{//产品的具体操作函数指针void (*Operation)(void);
}Product;///
/// 具体产品1
///
typedef struct
{//继承自抽象产品Product base;
}ConcreteProduct1;///
/// 具体产品2
///
typedef struct
{//继承自抽象产品Product base;
}ConcreteProduct2;///
/// 具体产品1的操作
///
///
void Product1Operation(void)
{std::cout << "你好，产品1" << std::endl;
}///
/// 具体产品2的操作
///
///
void Product2Operation(void)
{std::cout << "你好，产品2" << std::endl;
}///
/// 抽象工厂
///
typedef struct
{/// /// 生产产品的工厂方法指针/// Product* (*FactoryMethod)();
}Creator;///
/// 具体工厂1
///
typedef struct
{/// /// 继承自抽象工厂/// Creator base;
}ConcreteCreator1;///
/// 具体工厂2
///
typedef struct
{///
/// 继承自抽象工厂
/// Creator base;
}ConcreteCreator2;///
/// 工厂方法1，返回生产出的产品1
///
///
/// 工厂方法2，返回生产出的产品2
///
///
/// 客户端
///
///
void ClientCode(Creator* creator)
{std::cout << "我是使用者，我不管具体使用的是啥: \n";SomeOperation(creator);
}void C_FactoryMethod(void)
{std::cout << "C语言版本的工厂方法" << std::endl;std::cout << "工厂1启动\n";ConcreteCreator1 creator1;creator1.base.FactoryMethod = FactoryMethod1;ClientCode(&creator1.base);std::cout << "工厂2启动\n";ConcreteCreator2 creator2;creator2.base.FactoryMethod = FactoryMethod2;ClientCode(&creator2.base);
} 运行的效果
在C语言环境下，我通过结构体的套娃实现了继承的效果，函数指针模拟了方法重写的效果出来
抽象产品，包含抽象产品做事的函数指针
具体产品，在结构体定义的时候包含抽象产品的结构体，这样就有了做事的函数指针了，那么后面初始化具体产品的时候就需要把具体产品需要做的事(也就是函数指针指向的函数)绑定上去就可以了。同理具体工厂的弄法也是类似的。
在客户使用的时候，就可以通过父结构体来处理不同的工厂，生产的不同的产品，产品再做不同的事情，而不需要去直接访问具体的产品的结构体中的方法。
只是说，在C语言的环境下，它的结构体不能包含函数，但是可以包含函数指针，这样也算是间接的包含了函数.
就像它网页上说的那样
- 创建者和具体产品直接没有很紧密的联系
- 后续加入新的创建者，新的产品只需要按照这个模式添加就可以，不需要改原来的代码
抽象工厂方法
抽象工厂方法的介绍: https://refactoringguru.cn/design-patterns/abstract-factory
抽象工厂方法的C++实现: https://refactoringguru.cn/design-patterns/abstract-factory/cpp/example
这个给我的感觉就是工厂方法的升级版本~
类似于工厂方法，但是这个更进一步,更细了
可以生产更多的"产品"，“产品”可以做的"事"更多
但是套路还是和工厂方法类似
我的理解就是
不同的"工厂"生产不同的"产品"
不同的“产品”可以做不同的"事"
不同的"工厂"都有一个统一的基类(我叫它抽象工厂类)，它都能生产"产品"
不同的"产品"都有一个统一的基类(我叫它抽象产品类)，它都能做"事"
如果用一个图(直白的图，不是UML图)来说，大概就是这样
抽象工厂可以生产两种抽象产品，分别事抽象产品A和B
抽象产品A只能干一种事
抽象产品B可以干两种事，分别是事情1和事情2.
然后抽象工厂，通过继承得到了两个不同的工厂
然后抽象产品，通过继承得到了4种产品~
也是类似的，客户不需要直接解除具体的工厂和产品，它只需要知道工厂可以生产产品，产品可以干活就可以了，具体的无需知晓。
代码实现，也是函数指针+结构体套娃的方式
#include
#include
#include ///
/// 抽象产品A
///
typedef struct
{/// /// 抽象产品A干活/// ///
/// 具体产品A1
///
typedef struct
{//继承自抽象产品AAbstractProductA base;
}ConcreteProductA1;///
/// 具体产品A1干活
///
///
void UsefullFunctionA1Operation(void)
{std::cout << "具体产品A1干活.\r\n";
}///
/// 具体产品A2
///
typedef struct
{//继承自抽象产品AAbstractProductA base;
}ConcreteProductA2;///
/// 具体产品A2干活
///
///
void UsefullFunctionA2Operation(void)
{std::cout << "具体产品A2干活.\r\n";
}///
/// 抽象产品B
///
typedef struct
{/// /// 抽象产品B干活1/// /// /// 抽象产品B干活2/// ///
/// 具体产品B1
///
typedef struct
{/// /// 继承自抽象产品B/// AbstractProductB base;
}ConcreteProductB1;///
/// 具体产品B2
///
typedef struct
{/// /// 继承自抽象产品B/// AbstractProductB base;
}ConcreteProductB2;///
/// 具体产品B1干活1
///
///
void UsefullFunctionB1Operation(void)
{std::cout << "具体产品B1干活1.\r\n";
}///
/// 具体产品B2干活1
///
///
void UsefullFunctionB2Operation(void)
{std::cout << "具体产品B2干活1.\r\n";
}///
/// 具体产品B1干活2
///
///
void AnotherUsefulFunctionB1(AbstractProductA* collaborator)
{std::cout << "具体产品B1干活2.\r\n";std::cout << "顺带--->";collaborator->UsefullFunctionA();
}///
/// 具体产品B2干活2
///
///
void AnotherUsefulFunctionB2(AbstractProductA* collaborator)
{std::cout << "具体产品B2干活2.\r\n";std::cout << "顺带--->";collaborator->UsefullFunctionA();
}///
/// 抽象工厂
///
typedef struct
{/// /// 生产抽象产品A/// /// /// 生产抽象产品B/// ///
/// 具体工厂1
///
typedef struct
{/// /// 继承自抽象工厂/// AbstracFactory base;
}ConcreteFactory1;///
/// 生产具体产品A1
///
///
///
/// 生产具体产品B1
///
///
///
/// 具体工厂2
///
typedef struct
{/// /// 继承自抽象工厂/// AbstracFactory base;
}ConcreteFactory2;///
/// 生产具体产品A2
///
///
///
/// 生产具体产品B2
///
///
///
/// 客户端
///
///
void ClientCode( AbstracFactory* factory)
{AbstractProductA* a = factory->CreateProductA();AbstractProductB* b = factory->CreateProductB();a->UsefullFunctionA();b->UsefullFunctionB();b->AnotherUsefulFunctionB(a);free(a);free(b);
}void C_AbstractFactory(void)
{std::cout << "C语言版本的抽象工厂方法" << std::endl;std::cout << "我是使用者，我不管具体使用的是啥:\n";std::cout << "具体工厂1:\n";ConcreteFactory1 f1;f1.base.CreateProductA = FactoryCreateProductA1;f1.base.CreateProductB = FactoryCreateProductB1;ClientCode(&f1.base);std::cout << "具体工厂2:\n";ConcreteFactory2 f2;f2.base.CreateProductA = FactoryCreateProductA2;f2.base.CreateProductB = FactoryCreateProductB2;ClientCode(&f2.base);
}
运行的效果
生成器
生成器的介绍: https://refactoringguru.cn/design-patterns/builder
生成器的C++实现: https://refactoringguru.cn/design-patterns/builder/cpp/example
我对这个设计模式的理解:
某些复杂的对象，可能是由很多个小对象组成的，初始化这个复杂对象需要连带初始化许多的小对象
但是复杂的对象有时候，需要将某些功能增加或者删除以实现别的需求，但是连带的这些初始化接口可能就有些出现"有些用到，有些用不到"的情况，造成很大的浪费，代码也不简洁~
那么如果把复杂对象的构建初始化，拆散，分解成可以独立的接口，而不是原来一股脑的写一个大的接口来初始化，由一个另外的类(也叫主管)来管理组合需要用的小对象的初始化。