c++工厂模式

最新推荐文章于 2023-06-11 13:58:55 发布
最新推荐文章于 2023-06-11 13:58:55 发布
阅读量333 收藏
点赞数
分类专栏： 设计模式

以下是我自己学习设计模式的思考总结。

简单工厂模式

简单工厂模式是工厂模式中最简单的一种，他可以用比较简单的方式隐藏创建对象的细节，一般只需要告诉工厂类所需要的类型，工厂类就会返回需要的产品类，但客户端看到的只是产品的抽象对象，无需关心到底是返回了哪个子类。客户端唯一需要知道的具体子类就是工厂子类。除了这点，基本是达到了依赖倒转原则的要求。

 

假如，我们不用工厂类，只用AbstractProduct和它的子类，那客户端每次使用不同的子类的时候都需要知道到底是用哪一个子类，当类比较少的时候还没什么问题，但是当类比较多的时候，管理起来就非常的麻烦了，就必须要做大量的替换，一个不小心就会发生错误。

而使用了工厂类之后，就不会有这样的问题，不管里面多少个类，我只需要知道类型号即可。不过，这里还有一个疑问，那就是如果我每次用工厂类创建的类型都不相同，这样修改起来的时候还是会出现问题，还是需要大量的替换。所以简单工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

客户只需要知道SimpleFactory就可以了，使用的时候也是使用的AbstractFactory，这样客户端只在第一次创建工厂的时候是知道具体的细节的，其他时候它都只知道AbstractFactory，这样就完美的达到了依赖倒转的原则。

常用的场景

例如部署多种数据库的情况，可能在不同的地方要使用不同的数据库，此时只需要在配置文件中设定数据库的类型，每次再根据类型生成实例，这样，不管下面的数据库类型怎么变化，在客户端看来都是只有一个AbstractProduct，使用的时候根本无需修改代码。提供的类型也可以用比较便于识别的字符串，这样不用记很长的类名，还可以保存为配置文件。

这样，每次只需要修改配置文件和添加新的产品子类即可。

所以简单工厂模式一般应用于多种同类型类的情况，将这些类隐藏起来，再提供统一的接口，便于维护和修改。

优点

1.隐藏了对象创建的细节，将产品的实例化推迟到子类中实现。

2.客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂就行了，提供的类型也可以用比较便于识别的字符串。

3.方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。

4.遵循了依赖倒转原则。

缺点

1.要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，而所有的类又必须要添加一种方法，则会是非常麻烦的事情。或者是一种类另一种类有几种方法不相同，客户端无法知道是哪一个产品子类，也就无法调用这几个不相同的方法。

2.每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。

C++实现代码

 1 #ifndef _ABSTRACTPRODUCT_H_
 2 #define _ABSTRACTPRODUCT_H_
 3 
 4 
 5 #include <stdio.h>
 6 
 7 
 8 class AbstractProduct{
 9 
10 public:
11     AbstractProduct();
12     virtual ~AbstractProduct();
13     
14 public:
15     virtual void operation() = 0;
16 };
17 
18 class ProductA:public AbstractProduct{
19 
20 public:
21     ProductA();
22     virtual ~ProductA();
23     
24 public:
25     void operation();
26 };
27 
28 class ProductB:public AbstractProduct{
29 
30 public:
31     ProductB();
32     ~ProductB();
33     
34 public:
35     void operation();
36 };
37 
38 #endif
AbstractProduct.h 
 1 #include "AbstractProduct.h"
 2 
 3 
 4 
 5 AbstractProduct::AbstractProduct(){
 6 }
 7 
 8 
 9 AbstractProduct::~AbstractProduct(){
10 }
11 
12 
13 ProductA::ProductA(){
14 }
15 
16 
17 ProductA::~ProductA(){
18 }
19 
20 
21 void ProductA::operation(){
22     fprintf(stderr,"productA operation!\n");
23 }
24 
25 
26 ProductB::ProductB(){
27 }
28 
29 
30 ProductB::~ProductB(){
31 }
32 
33 
34 void ProductB::operation(){
35     fprintf(stderr,"productB operation!\n");
36 }
AbstractProduct.cpp

 

 1 #ifndef _SIMPLEFACTORY_H_
 2 #define _SIMPLEFACTROY_H_
 3 
 4 #include <stdio.h>
 5 #include "AbstractProduct.h"
 6 
 7 
 8 class AbstractFactory{
 9 
10 public:
11     AbstractFactory();
12     virtual ~AbstractFactory();
13     
14 public:
15     virtual AbstractProduct* createProduct(int type) = 0;    
16 };
17 
18 
19 class SimpleFactory:public AbstractFactory{
20 
21 public:
22     SimpleFactory();
23     ~SimpleFactory();
24     
25 public:
26     AbstractProduct* createProduct(int type);
27 };
28 
29 #endif
SimpleFactory.h 
 1 #include "SimpleFactory.h"
 2 
 3 
 4 AbstractFactory::AbstractFactory(){
 5 }
 6 
 7 
 8 AbstractFactory::~AbstractFactory(){
 9 }
10 
11 
12 SimpleFactory::SimpleFactory(){
13 }
14 
15 
16 SimpleFactory::~SimpleFactory(){
17 }
18 
19 
20 AbstractProduct* SimpleFactory::createProduct(int type){
21     AbstractProduct* temp = NULL;
22     switch(type)
23     {
24     case 1:
25         temp = new ProductA();
26         break;
27     case 2:
28         temp = new ProductB();
29         break;
30     default:
31         break;
32     }
33     return temp;
34 }
SimpleFactory.cpp 
 1 #include "SimpleFactory.h"
 2 
 3 
 4 int main(){
 5     AbstractFactory* factory = new SimpleFactory();
 6     AbstractProduct* product = factory->createProduct(1);
 7     product->operation();
 8     delete product;
 9     product = NULL;
10     
11     product = factory->createProduct(2);
12     product->operation();
13     delete product;
14     product = NULL;
15     return 0;
16 }
client.cpp 
1 g++ -o client client.cpp SimpleFactory.cpp AbstractProduct.cpp

结果

 

工厂模式

工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

既然每次都要判断，那我就把这些判断都生成一个工厂子类，这样，每次添加产品子类的时候，只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题，如果产品数量足够多，要维护的量就会增加，好在一般工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

同样工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

 

常用的场景

基本与简单工厂模式一致，只不过是改进了简单工厂模式中的开放-封闭原则的缺陷，使得模式更具有弹性。将实例化的过程推迟到子类中，由子类来决定实例化哪个。

优点

基本与简单工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。

缺点

与简单工厂模式差不多。

C++实现代码

 1 #ifndef _ABSTRACTPRODUCT_H_
 2 #define _ABSTRACTPRODUCT_H_
 3 
 4 
 5 #include <stdio.h>
 6 
 7 
 8 class AbstractProduct{
 9 
10 public:
11     AbstractProduct();
12     virtual ~AbstractProduct();
13     
14 public:
15     virtual void operation() = 0;
16 };
17 
18 class ProductA:public AbstractProduct{
19 
20 public:
21     ProductA();
22     virtual ~ProductA();
23     
24 public:
25     void operation();
26 };
27 
28 class ProductB:public AbstractProduct{
29 
30 public:
31     ProductB();
32     ~ProductB();
33     
34 public:
35     void operation();
36 };
37 
38 #endif
AbstractProduct.h 
 1 #include "AbstractProduct.h"
 2 
 3 
 4 
 5 AbstractProduct::AbstractProduct(){
 6 }
 7 
 8 
 9 AbstractProduct::~AbstractProduct(){
10 }
11 
12 
13 ProductA::ProductA(){
14 }
15 
16 
17 ProductA::~ProductA(){
18 }
19 
20 
21 void ProductA::operation(){
22     fprintf(stderr,"productA operation!\n");
23 }
24 
25 
26 ProductB::ProductB(){
27 }
28 
29 
30 ProductB::~ProductB(){
31 }
32 
33 
34 void ProductB::operation(){
35     fprintf(stderr,"productB operation!\n");
36 }
AbstractProduct.cpp 
 1 #ifndef _SIMPLEFACTORY_H_
 2 #define _SIMPLEFACTROY_H_
 3 
 4 #include <stdio.h>
 5 #include "AbstractProduct.h"
 6 
 7 
 8 class AbstractFactory{
 9 
10 public:
11     AbstractFactory();
12     virtual ~AbstractFactory();
13     
14 public:
15     virtual AbstractProduct* createProduct() = 0;    
16 };
17 
18 
19 class FactoryA:public AbstractFactory{
20 
21 public:
22     FactoryA();
23     ~FactoryA();
24     
25 public:
26     AbstractProduct* createProduct();
27 };
28 
29 
30 class FactoryB:public AbstractFactory{
31 
32 public:
33     FactoryB();
34     ~FactoryB();
35     
36 public:
37     AbstractProduct* createProduct();
38 };
39 #endif
AbstractFactory.h 
 1 #include "AbstractFactory.h"
 2 
 3 
 4 AbstractFactory::AbstractFactory(){
 5 }
 6 
 7 
 8 AbstractFactory::~AbstractFactory(){
 9 }
10 
11 
12 FactoryA::FactoryA(){
13 }
14 
15 
16 FactoryA::~FactoryA(){
17 }
18 
19 
20 AbstractProduct* FactoryA::createProduct(){
21     AbstractProduct* temp = NULL;
22     temp = new ProductA();
23     return temp;
24 }
25 
26 
27 FactoryB::FactoryB(){
28 }
29 
30 
31 FactoryB::~FactoryB(){
32 }
33 
34 
35 AbstractProduct* FactoryB::createProduct(){
36     AbstractProduct* temp = NULL;
37     temp = new ProductB();
38     return temp;
39 }
AbstractFactory.cpp 
 1 #include "AbstractFactory.h"
 2 
 3 
 4 int main(){
 5     AbstractFactory* factory = new FactoryA();
 6     AbstractProduct* product = factory->createProduct();
 7     product->operation();
 8     delete product;
 9     product = NULL;
10     delete factory;
11     factory = NULL;
12     
13     factory = new FactoryB();
14     product = factory->createProduct();
15     product->operation();
16     delete product;
17     product = NULL;
18     delete factory;
19     factory = NULL;
20     return 0;
21 }
client.cpp 
1 g++ -o client client.cpp AbstractFactory.cpp AbstractProduct.cpp

结果

 

抽象工厂模式

抽象工厂模式就变得比工厂模式更为复杂，就像上面提到的缺点一样，工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，我们可以把他们一起视作一组，然后好几组产品构成一族。

此时，客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品，而子类的一种方法产生一种类型的产品。在客户端看来只有AbstractProductA和AbstractProductB两种产品，使用的时候也是直接使用这两种产品。而通过工厂来识别是属于哪一族产品。

产品ProductA_1和ProductB_1构成一族产品，对应于有Factory1来创建，也就是说Factory1总是创建的ProductA_1和ProductB_1的产品，在客户端看来只需要知道是哪一类工厂和产品组就可以了。一般来说， ProductA_1和ProductB_1都是适应同一种环境的，所以他们会被归为一族。

常用的场景

例如Linux和windows两种操作系统下，有2个挂件A和B，他们在Linux和Windows下面的实现方式不同，Factory1负责产生能在Linux下运行的挂件A和B，Factory2负责产生能在Windows下运行的挂件A和B，这样如果系统环境发生变化了，我们只需要修改工厂就行了。

优点

1.封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。

2.可以支持不同类型的产品，使得模式灵活性更强。

3.可以非常方便的使用一族中间的不同类型的产品。

缺点

1.结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

C++实现代码

 1 #ifndef _ABSTRACTPRODUCTA_H_
 2 #define _ABSTRACTPRODUCTA_H_
 3 
 4 
 5 #include <stdio.h>
 6 
 7 
 8 class AbstractProductA{
 9 
10 public:
11     AbstractProductA();
12     virtual ~AbstractProductA();
13     
14 public:
15     virtual void operationA() = 0;
16 };
17 
18 class ProductA_1:public AbstractProductA{
19 
20 public:
21     ProductA_1();
22     virtual ~ProductA_1();
23     
24 public:
25     void operationA();
26 };
27 
28 class ProductA_2:public AbstractProductA{
29 
30 public:
31     ProductA_2();
32     ~ProductA_2();
33     
34 public:
35     void operationA();
36 };
37 
38 #endif
AbstractProductA.h 
 1 #include "AbstractProductA.h"
 2 
 3 
 4 
 5 AbstractProductA::AbstractProductA(){
 6 }
 7 
 8 
 9 AbstractProductA::~AbstractProductA(){
10 }
11 
12 
13 ProductA_1::ProductA_1(){
14 }
15 
16 
17 ProductA_1::~ProductA_1(){
18 }
19 
20 
21 void ProductA_1::operationA(){
22     fprintf(stderr,"productA_1 operation!\n");
23 }
24 
25 
26 ProductA_2::ProductA_2(){
27 }
28 
29 
30 ProductA_2::~ProductA_2(){
31 }
32 
33 
34 void ProductA_2::operationA(){
35     fprintf(stderr,"productA_2 operation!\n");
36 }
AbstractProductA.cpp 
 1 #ifndef _ABSTRACTPRODUCTB_H_
 2 #define _ABSTRACTPRODUCTB_H_
 3 
 4 
 5 #include <stdio.h>
 6 
 7 
 8 class AbstractProductB{
 9 
10 public:
11     AbstractProductB();
12     virtual ~AbstractProductB();
13     
14 public:
15     virtual void operationB() = 0;
16 };
17 
18 class ProductB_1:public AbstractProductB{
19 
20 public:
21     ProductB_1();
22     virtual ~ProductB_1();
23     
24 public:
25     void operationB();
26 };
27 
28 class ProductB_2:public AbstractProductB{
29 
30 public:
31     ProductB_2();
32     ~ProductB_2();
33     
34 public:
35     void operationB();
36 };
37 
38 #endif
AbstractProductB.h 
 1 #include "AbstractProductB.h"
 2 
 3 
 4 
 5 AbstractProductB::AbstractProductB(){
 6 }
 7 
 8 
 9 AbstractProductB::~AbstractProductB(){
10 }
11 
12 
13 ProductB_1::ProductB_1(){
14 }
15 
16 
17 ProductB_1::~ProductB_1(){
18 }
19 
20 
21 void ProductB_1::operationB(){
22     fprintf(stderr,"productB_1 operation!\n");
23 }
24 
25 
26 ProductB_2::ProductB_2(){
27 }
28 
29 
30 ProductB_2::~ProductB_2(){
31 }
32 
33 
34 void ProductB_2::operationB(){
35     fprintf(stderr,"productB_2 operation!\n");
36 }
AbstractProductB.cpp 
 1 #ifndef _SIMPLEFACTORY_H_
 2 #define _SIMPLEFACTROY_H_
 3 
 4 #include <stdio.h>
 5 #include "AbstractProductA.h"
 6 #include "AbstractProductB.h"
 7 
 8 
 9 class AbstractFactory{
10 
11 public:
12     AbstractFactory();
13     virtual ~AbstractFactory();
14     
15 public:
16     virtual AbstractProductA* createProductA() = 0;    
17     virtual AbstractProductB* createProductB() = 0;    
18 };
19 
20 
21 class Factory1:public AbstractFactory{
22 
23 public:
24     Factory1();
25     ~Factory1();
26     
27 public:
28     AbstractProductA* createProductA();
29     AbstractProductB* createProductB();
30 };
31 
32 
33 class Factory2:public AbstractFactory{
34 
35 public:
36     Factory2();
37     ~Factory2();
38     
39 public:
40     AbstractProductA* createProductA();
41     AbstractProductB* createProductB();
42 };
43 #endif
AbstractFactory.h 
 1 #include "AbstractFactory.h"
 2 
 3 
 4 AbstractFactory::AbstractFactory(){
 5 }
 6 
 7 
 8 AbstractFactory::~AbstractFactory(){
 9 }
10 
11 
12 Factory1::Factory1(){
13 }
14 
15 
16 Factory1::~Factory1(){
17 }
18 
19 
20 AbstractProductA* Factory1::createProductA(){
21     AbstractProductA* temp = NULL;
22     temp = new ProductA_1();
23     return temp;
24 }
25 
26 
27 AbstractProductB* Factory1::createProductB(){
28     AbstractProductB* temp = NULL;
29     temp = new ProductB_1();
30     return temp;
31 }
32 
33 
34 Factory2::Factory2(){
35 }
36 
37 
38 Factory2::~Factory2(){
39 }
40 
41 
42 AbstractProductA* Factory2::createProductA(){
43     AbstractProductA* temp = NULL;
44     temp = new ProductA_2();
45     return temp;
46 }
47 
48 
49 AbstractProductB* Factory2::createProductB(){
50     AbstractProductB* temp = NULL;
51     temp = new ProductB_2();
52     return temp;
53 }
AbstractFactory.cpp 
 1 #include "AbstractFactory.h"
 2 
 3 
 4 int main(){
 5 
 6     AbstractFactory* factory = new Factory1();
 7     AbstractProductA* productA = factory->createProductA();
 8     AbstractProductB* productB = factory->createProductB();
 9     productA->operationA();
10     productB->operationB();
11     
12     delete factory;
13     factory = NULL;
14     delete productA;
15     productA = NULL;
16     delete productB;
17     productB = NULL;
18     
19     factory = new Factory2();
20     productA = factory->createProductA();
21     productB = factory->createProductB();
22     productA->operationA();
23     productB->operationB();
24     
25     delete factory;
26     factory = NULL;
27     delete productA;
28     productA = NULL;
29     delete productB;
30     productB = NULL;
31     return 0;
32 }
client.cpp 
1 g++ -o client AbstractProductA.cpp AbstractProductB.cpp AbstractFactory.cpp client.cpp

结果

szcarewell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言工厂模式
08-05
最近一直在看设计模式，想把自己的学习笔记与大家分享一下，如果能帮助大家的话，我会非常高兴，同时也欢迎大家指出里面的不足
C语言设计模式——简单工厂模式
穿越临界点的博客
05-08 3604
设计模式是学习和使用面向对象编程不可绕过的一个里程碑，学习设计模式有助于深入理解和灵活使用面向对象思想，设计出更高质量的代码。
C语言实现简单工厂模式
lijianhua003的博客
08-17 1123
工厂模式是一种面向对象的模式，是23种里面的一种，c语言是面向过程，但我们可以用类与对象（结构体）实现一个简单的面向对象模式，跟分文件编程很像。
C 语言实现简单工厂模式
最新发布
kakaka666的博客
06-11 1396
印象中，设计模式是由面向对象的语言(C++、JAVA)才能完成的，而 C 语言是面向过程的语言，不能实现设计模式。但C 语言中有函数指针回调函数等机制，使用这些机制便能写出面向对象的优秀程序。LINUX 操作系统，采用 C 语言写的，但是里面很多模块实现都是通过面向对象的设计方式实现的，这也是很多人初看 Linux 源码看得云里雾里的原因。面向过程（Procedure Oriented 简称 PO）： 把事情拆分成几个步骤（相当于拆分成一个个的方法和数据），然后按照一定的顺序执行。
简单工厂模式（C语言实现）
Tyrion Lannister's Special column
06-19 2846
一. 简单工厂模式 简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。举个例子，有一家电子产品生产厂家，它只有一个工厂，能够生产两种型号的产品，A 和 B。可以想像一下，A是电吹风，B是电风扇。客户需要什么样的吹风类产品，一定要显示地告诉生产工厂。
C++设计模式之工厂方法模式
12-31
之前讲到了C++设计模式——简单工厂模式，由于简单工厂模式的局限性，比如：工厂现在能生产ProductA、ProductB和ProductC三种产品了，此时，需要增加生产ProductD产品；那么，首先是不是需要在产品枚举类型中添加新...
C++工厂模式
06-05
工厂模式C++
java c++ 工厂模式源代码
12-31
java c++ 工厂模式源代码
c++设计模式-工厂方法模式
06-04
c++设计模式-创建型模式-工厂方法模式-最简单的源码-qt工程
c语言工厂模式,C语言设计模式-工厂模式
weixin_33835368的博客
05-19 342
工厂模式工厂模式是比较简单，也是比较好用的一种方式。根本上说，工厂模式的目的就根据不同的要求输出不同的产品。比如说吧，有一个生产鞋子的工厂，它能生产皮鞋，也能生产胶鞋。如果用代码设计，应该怎么做呢？#define LEATHER_TYPE 0x01#define RUBBER_TYPE 0x02typedef struct _Shoe{int type;void (*print_shoe)(st...
C语言简单工厂模式
ailx10
04-06 55
实现一个简单的工厂,实现对原始报文按照指定条件处理,输出处理后的新报文.思路:在工厂函数中传入回调函数实现.回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。参考代码:root@gt:...
设计模式之——工厂模式(C)
皮斯特劳沃
11-17 1839
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/41219129 主要介绍抽象工厂模式、工厂方法和抽象工厂之间的区别： （1）抽象工厂模式：它提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。 抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而无需知道实际产出的具体产品是什么。这样，客户就从具体的产品中解耦出来。 抽象工厂类图如下所示：
三种工厂模式的分析以及C++实现
weixin_30834019的博客
06-19 367
以下是我自己学习设计模式的思考总结。 简单工厂模式 简单工厂模式是工厂模式中最简单的一种，他可以用比较简单的方式隐藏创建对象的细节，一般只需要告诉工厂类所需要的类型，工厂类就会返回需要的产品类，但客户端看到的只是产品的抽象对象，无需关心到底是返回了哪个子类。客户端唯一需要知道的具体子类就是工厂子类。除了这点，基本是达到了依赖倒转原则的要求。 假如，我们不用工厂类，只用AbstractP...
工厂模式--C语言实现
05-30 783
工厂模式，其实就是C++中的类的继承，只不过用C语言中的函数指针来实现了。 假设现在的需求是公司生产一系列产品，包括椅子，床等，要求先生产产品，然后将生产的产品销售出去。将来可能要增加新的产品，不希望修改现有的核心代码流程，满足开闭原则。 /* 工厂模式，其实就是C++中的类的继承，只不过用C语言中的函数指针来实现了 */ /* 假设现在的需求是公司生产一系列产品，包括椅子，床等，要求先生产产品，然后将 生产的产品销售出去。 将来可能要增加新的产品，不希望修改现有的核
用C语言实现简单工厂模式！
weixin_46564301的博客
03-12 443
虽然C语言是面向过程的编程语言，但是我们在设计程序的时候，可以考虑用面向对象的方式去设计，这样提高我们程序的“高内聚、低耦合”特性，便于维护。
C语言实现工厂模式
VT——csj
01-22 2042
工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。＿＿来自维基百科． 实现方法： #include #include typedef struct func_ {         char name;//命令名         void (*factory)(void);//命令函数指针 }func_t; void factory_A(vo
C语言实现设计模式之简单工厂模式（无内存泄露）
马叔叔的专栏
09-06 1405
最近工作之余研究一下设计模式细节方面的东西，很多经典的东西需要一遍遍去读、去理解，设计模式就是这样的程序设计的经典之作。 我一直坚信学习是把书读薄，又把书读厚的过程，最终达到游刃有余。 言归正传，接下来是研究设计模式自己亲手写下的一段代码，看见网上也有很多人发了关于使用简单工厂实现计算的代码，可是都是浅尝辄止，大多存在内存泄露，没有回收资源的情况，本人发此博文，绝非卖弄，只是充实自我生活，升华
设计模式之工厂模式（C语言）
Hongggggggg
12-09 501
介绍： ​ 工厂模式是一种创建型设计模式； 作用： ​ 隐蔽具体的生产逻辑，根据不同的要求生产出不同的产品，就像switch-case一样； 类比： ​ 一个衣服工厂可以根据不同的诉求生产出不同面料的衣服； 代码示例： typedef enum { COTTON, LEATHER, FABRIC_MAX, } typedef struct _Clothing { int fabric; /*面料*/ void (*generate_clothing)(void
c++ 工厂模式
05-27
在 C++ 中使用工厂模式更为常见，因为 C++ 支持面向对象编程。下面是一个 C++ 工厂模式的例子，使用了抽象基类和纯虚函数： ```c++ #include using namespace std; // 定义抽象基类 class Shape { public: ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值