这个文章的目的
我很早就知道有一个可以学设计模式的网站

一个乌克兰老哥搞得学设计模式的网站，还有爱好者直接翻译成中文的页面~
我一直没能有机会学一学~
每一种设计模式都有一个很生动的图解，还有对应的代码实现，其中也有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
/// 
/// 
Product* FactoryMethod1()
{//生产具体产品1ConcreteProduct1* ptr = (ConcreteProduct1*)malloc(sizeof(ConcreteProduct1));if (ptr != NULL){//绑定具体产品1的操作ptr->base.Operation = Product1Operation;}//返回抽象产品指针return (Product*)ptr;
}/// 

/// 工厂方法2，返回生产出的产品2
/// 
/// 
Product* FactoryMethod2()
{//生产具体产品2ConcreteProduct2* ptr = (ConcreteProduct2*)malloc(sizeof(ConcreteProduct2));if (ptr != NULL){//绑定具体产品2的操作ptr->base.Operation = Product2Operation;}//返回抽象产品指针return (Product*)ptr;
}void SomeOperation(Creator* _this)
{//具体工厂尝试生产出对应的抽象产品Product* product = _this->FactoryMethod();std::cout << "工厂生产出: ";//抽象产品做具体的动作product->Operation();free(product);
}
/// 

/// 客户端
/// 
/// 
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语言的环境下，它的结构体不能包含函数，但是可以包含函数指针，这样也算是间接的包含了函数.

就像它网页上说的那样

1. 创建者和具体产品直接没有很紧密的联系
2. 后续加入新的创建者，新的产品只需要按照这个模式添加就可以，不需要改原来的代码

抽象工厂方法

抽象工厂方法的介绍: 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干活/// 
/// void (*UsefullFunctionA)(void);
}AbstractProductA;/// 

/// 具体产品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/// 
/// void (*UsefullFunctionB)(void);/// 
/// 抽象产品B干活2/// 
/// void (*AnotherUsefulFunctionB)(AbstractProductA * collaborator);
}AbstractProductB;/// 

/// 具体产品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/// 
/// AbstractProductA* (*CreateProductA)(void);/// 
/// 生产抽象产品B/// 
/// AbstractProductB* (*CreateProductB)(void);
}AbstracFactory;// 

/// 具体工厂1
/// 
typedef struct
{/// 
/// 继承自抽象工厂/// 
AbstracFactory base;
}ConcreteFactory1;/// 

/// 生产具体产品A1
/// 
/// 
/// 
AbstractProductA* FactoryCreateProductA1(void)
{ConcreteProductA1* p = (ConcreteProductA1*)malloc(sizeof(ConcreteProductA1));if (p != NULL){p->base.UsefullFunctionA = UsefullFunctionA1Operation;}return (AbstractProductA*)p;
}
/// 

/// 生产具体产品B1
/// 
/// 
/// 
AbstractProductB* FactoryCreateProductB1(void)
{ConcreteProductB1* p = (ConcreteProductB1*)malloc(sizeof(ConcreteProductB1));if (p != NULL){p->base.UsefullFunctionB = UsefullFunctionB1Operation;p->base.AnotherUsefulFunctionB = AnotherUsefulFunctionB1;}return (AbstractProductB*)p;
}// 

/// 具体工厂2
/// 
typedef struct
{/// 
/// 继承自抽象工厂/// 
AbstracFactory base;
}ConcreteFactory2;/// 

/// 生产具体产品A2
/// 
/// 
/// 
AbstractProductA* FactoryCreateProductA2(void)
{ConcreteProductA2* p = (ConcreteProductA2*)malloc(sizeof(ConcreteProductA2));if (p != NULL){p->base.UsefullFunctionA = UsefullFunctionA2Operation;}return (AbstractProductA*)p;
}
/// 

/// 生产具体产品B2
/// 
/// 
/// 
AbstractProductB* FactoryCreateProductB2(void)
{ConcreteProductB2* p = (ConcreteProductB2*)malloc(sizeof(ConcreteProductB2));if (p != NULL){p->base.UsefullFunctionB = UsefullFunctionB2Operation;p->base.AnotherUsefulFunctionB = AnotherUsefulFunctionB2;}return (AbstractProductB*)p;
}/// 

/// 客户端
/// 
/// 
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
我对这个设计模式的理解:
某些复杂的对象，可能是由很多个小对象组成的，初始化这个复杂对象需要连带初始化许多的小对象
但是复杂的对象有时候，需要将某些功能增加或者删除以实现别的需求，但是连带的这些初始化接口可能就有些出现"有些用到，有些用不到"的情况，造成很大的浪费，代码也不简洁~
那么如果把复杂对象的构建初始化，拆散，分解成可以独立的接口，而不是原来一股脑的写一个大的接口来初始化，由一个另外的类(也叫主管)来管理组合需要用的小对象的初始化。