c++工厂模式

2023-10-27

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

简单工厂模式

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

假如，我们不用工厂类，只用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

结果

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

设计模式

c++工厂模式的相关文章

设计模式——Visitor(访问者)模式

目录前言 1 定义 2 适用性 3 结构 3 1 结构图 3 2 参与者 4 Java实际应用举例以ASM技术为例 4 1 被访问对象 ClassReader 4 2 Visitor ClassVisitor 4 3 具体visitor
23种设计模式之装饰模式

装饰模式一个简陋的房子它可以让人在里面居住为人遮风避雨但如果给它进行装修那么它的居住环境就更加宜人了程序中的对象也与房子十分类似首先有一个相当于房子的对象然后经过不断装饰不断对其增加功能它就变成了使用功能更加强大的对
设计模式-单一职责原则介绍与理解

描述一个类应该专注于实现一个功能好处便于代码复用举例俄罗斯方块游戏首先可以想到的是游戏逻辑与界面的分离也就是说逻辑一个类界面部分一个类这样做的好处就是我们可以复用游戏逻辑的代码例如我们用java写了一个基于PC端的俄罗斯
设计模式三: 代理模式(Proxy) -- JDK的实现方式

简介代理模式属于行为型模式的一种控制对其他对象的访问起到中介作用代理模式核心角色真实角色代理角色按实现方式不同分为静态代理和动态代理两种意图控制对其它对象的访问类图实现 JDK自带了Proxy的实现下面我们先使用JD
python语法（高阶）-设计模式（单例模式）

参考内容黑马程序员
离散仿真引擎基础作业与练习

作业内容一简答题 1 解释 GameObjects 和 Assets 的区别与联系 2 下载几个游戏案例分别总结资源对象组织的结构 3 使用 debug 验证 MonoBehaviour 基本行为或事件触发条件 4 了解 GameO
C++ 装饰器模式

什么是装饰器模式装饰器模式是一种结构型设计模式实现了在不改变现有对象结构的的同时又拓展了新的功能装饰器本质上是对现有对象的重新包装同时装饰器又称为封装器如何理解装饰器模式以笔记本电脑为例当我们购买了一台新笔记本电脑但我们发现
java需会(转载)

一基础篇 1 1 Java基础面向对象的特征继承封装和多态 final finally finalize 的区别 Exception Error 运行时异常与一般异常有何异同请写出5种常见到的runtime exception i
计算资源合并模式——云计算架构常用设计模式

背景云计算的解决方案中最初设计可能有意遵循关注点分离的设计原则把操作分解为独立的计算单元以便可以单独托管和部署然而虽然这种策略可以帮助简化解决方案的逻辑实现但是在同一个应用程序中要部署大量的计算单元这会增加运行时的托管成本并
设计模式——导论

作为软件开发人员我们在平时工作的过程中往往需要编写很多的代码来实现我们的需求很多的时候会造成代码臃肿和代码冗余的情况这个时候我们需要引入一个理念设计模式设计模式存在的意义在于 1 使得我们的代码更加精炼 2 使我们代码的可读性更
设计模式（十）装饰器模式

装饰器模式是一种非常有用的结构型模式它允许我们在不改变类的结果的情况下为类添加新的功能我们来举例说明一下首先添加一组形状它们都实现了形状接口 public interface Shape String getShape class
设计模式（5）-适配器模式（Adapter Pattern）

适配器模式 Adapter Pattern 顾名思义就像变压器转接头差不多就像美国的生活电压是110V 中国是220V 就需要一个变压器将220V转换成110V 或者一个Type C接口想插如USB接口的东西你就需要一个转换器而这
单例模式的八种写法比较

单例模式是最常用到的设计模式之一熟悉设计模式的朋友对单例模式都不会陌生一般介绍单例模式的书籍都会提到饿汉式和懒汉式这两种实现方式但是除了这两种方式本文还会介绍其他几种实现单例的方式让我们来一起看看吧简介单例模式是一种常
java-IO流(5)-IO流中的设计模式（装饰器模式和适配器模式）的介绍

目录 1装饰器模式 1 1定义 1 2代码实现 1 3装饰器特点 1 4装饰器在IO流中的使用 2配适器模式 2 1Adapter适配器 2 2代码实例 2 3适配器特点 2 4适配器优缺点 2 5适配器在IO中的使用 3装饰器与适配器异同
设计模式——State(状态)模式

目录前言 1 定义 2 适用性 3 结构 3 1 结构图 3 2 参与者 4 应用举例 4 1 State TcpState 4 2 Context TcpConnection 4 3 ConcreteState ListeningTcp
设计模式-享元模式

一概念如果在一个系统中存在多个相同的对象那么只需要共享一份对象的拷贝而不必为每一次使用都创建新的对象目的是提高系统性能上面的概念乍一听好像单例模式其实不是单例模式只保存一个对象但是这里可以有很多个不同对象但是每个对象只有一
Java监听器与观察者模式

Java监听器与观察者模式 Java中的监听器 Listener 和观察者模式 Observer Pattern 都是用于处理对象间的事件通知和响应的设计模式它们的目的是在对象之间建立一种松散的耦合使得一个对象的状态变化可以通知到其他对
设计模式原型模式与 Spring 原型模式源码解析(包含Bean的创建过程)

原创疯狂的狮子Li 狮子领域程序圈 2023 12 19 10 30 发表于辽宁原型模式原型模式 Prototype模式是指用原型实例指定创建对象的种类并且通过拷贝这些原型创建新的对象原型模式是一种创建型设计模式允许一个
C++设计模式 #3策略模式（Strategy Method）

动机在软件构建过程中某些对象使用的的算法可能多种多样经常改变如果将这些算法都写在类中会使得类变得异常复杂而且有时候支持不频繁使用的算法也是性能负担如何在运行时根据需求透明地更改对象的算法将算法和对象本身解耦从而避免上述问题
C++设计模式 #3策略模式（Strategy Method）

动机在软件构建过程中某些对象使用的的算法可能多种多样经常改变如果将这些算法都写在类中会使得类变得异常复杂而且有时候支持不频繁使用的算法也是性能负担如何在运行时根据需求透明地更改对象的算法将算法和对象本身解耦从而避免上述问题

随机推荐

第65步时间序列建模实战：ARIMA建模（Eviews）

基于WIN10的64位系统演示一写在前面从这一期开始我们开始入坑时间序列模型时间序列是一种数据类型其中的数据点是按照时间顺序排列的这种数据类型常常出现在各个领域比如金融股票价格的历史变动气象过去几年的天气状况医学一
rdesktop连接windows主机提示被拒绝的解决方法

1 在待连接的Windows主机上依次右击我的电脑 gt 属性 gt 高级系统设置 gt 远程设置 gt 在远程桌面选项中选择允许运行任意版本远程桌面的连接 2 检查linux主机和待连接的Windows 主机是否可以相互ping通
Pytorch优化器全总结（一）SGD、ASGD、Rprop、Adagrad

目录写在前面一 torch optim SGD 随机梯度下降 SGD代码 SGD算法解析 1 MBGD Mini batch Gradient Descent 小批量梯度下降法 2 Momentum动量 3 NAG Nesterov a
从数字化视角看飞书产品

一观点总结 1 用户体验优秀飞书Office产品系列功能很贴心细节交互体验好飞书的周报功能吊打企微的周报功能 2 产品开放性欠缺从日常办公的视角多维表格功能强大但从企业数字化建设的角度首要工作是统一数据源管理虽然多维表格提
DevOps 之 Code 阶段工具 Git

代码编写阶段我们需要将不同版本的代码存储到一个仓库中大多数企业采用的版本控制系统就是 git 或者 svn 相比之下 git 作为版本控制系统居多而远程仓库 GitLab 也是大多数企业的首先因为它开源且活跃 Git Github
leetcode-每日一题2022.1.20 石子游戏 IX

题目力扣错误思路只管当前回合能够凑成移出的石子不是3的倍数代码 class Solution public bool stoneGameIX vector
使用PyTorch实现简单的RNN

使用PyTorch实现简单的RNN 假设 X t R n d
升级OpenSSH版本（安装telnet远程管理主机）

目录一 OpenSSH是什么二升级OpenSSH版本至8 9 1 环境介绍 2 检查是否安装telnet 3 安装telnet服务 4 启动telnet服务 5 安全文件关闭或者修改否则root无法telnet登录 6 安装依赖包
Face Anti-spoofing 简记-FaceForensics++: Learning to Detect Manipulated Facial Images

创新点 DeepFakes Face2Face FaceSwap 建立的假脸数据库总结假脸数据库 https github com ondyari FaceForensics 1 000个视频中的510 207图片包含segmenta
【单片机笔记】基于STM32F103C8的 USB 外部flash虚拟U盘

学习stm32已经很长时间了但是一直没有过多的学习stm32的USB部分因为实际工作还是用的比较少说起USB那就有的说了因为USB的功能很强大这里主要重点记录一下STM32的USB部分这个官方给的有专门USB库笔者目前使用的是
虚拟机怎么架设dns服务器,虚拟机centos7 DNS服务器搭建

服务器端前期工作切换到NAT模式 1 关闭防火墙以及SeLinux 防火墙相关设置 systemctl stop firewalld 临时关闭防火墙 systemctl disable firewalld 禁止开机启动防火墙 selin
[g2o] 程序使用g2o时报错，number_t does not name a type

问题描述更新了某些文件后导致g2o无法正常使用编译开源代码时出现了 number t does not name a type undefined reference to g2o Optimizable Graph addvert
使用IDEA自动生成UML类图和时序图

在UML设计的时候在已经写好代码的情况下想要得到类图除了使用processON等画图工具画图外也还可以使用IDEA中的工具实现自动生成的类图和时序图这里要注意的是 idea需要高级版也就是说社区版的idea并不具备这个功能可能需
字符游戏贪吃蛇（2）

首先是一些准备工作 include
js 根据身份证号或者出生日期，计算年龄

const idCard 110101191507288317 先计算出出生日期 var re eighteen d 6 d 4 d 2 d 2 d 3 0 9 X var arr data idCard match re eighteen
憨批的语义分割重制版1——Keras 搭建自己的PSPnet语义分割平台

憨批的语义分割重制版1 Keras 搭建自己的PSPnet语义分割平台注意事项学习前言什么是PSPNet模型代码下载 PSPNet实现思路一预测部分 1 主干网络介绍 2 加强特征提取结构 3 利用特征获得预测结果二训练部分
期货开户不同的资金可以做哪些品种

现在经济比较好大家兜里也都有些闲钱以前都是把闲钱放到银行可是银行利息低现在物价这么高都跑不赢通货膨胀就想到炒股炒期货炒基金都想要在这个期货市场上赚点意外之财都听说炒期货交易非常不错但是不知道期货交易需要多少资金门槛
Java 4-4、Log日志配置

Log日志配置均在application dev properties配置一 springboot自带的日志打印执行sql打印开关 logging level com a2j mapper debug 日志备份存放的文件名 log
Jenkins+maven+findbugs对java代码进行静态代码分析

一 POM xml的修改 1 在build里面配置代码如下
c++工厂模式

以下是我自己学习设计模式的思考总结简单工厂模式简单工厂模式是工厂模式中最简单的一种他可以用比较简单的方式隐藏创建对象的细节一般只需要告诉工厂类所需要的类型工厂类就会返回需要的产品类但客户端看到的只是产品的抽象对象无需关心到底是

c++工厂模式

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

简单工厂模式

常用的场景

优点

缺点

C++实现代码

工厂模式

常用的场景

优点

缺点

C++实现代码

抽象工厂模式

常用的场景

优点

缺点

C++实现代码

c++工厂模式 的相关文章

随机推荐

热门标签

c++工厂模式的相关文章