C/C++教程
C++笔记（11）工厂模式
本文主要是介绍C++笔记（11）工厂模式，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
建议直接空降至参考文献，点击链接
简单工厂模式
#include<iostream>
using namespace std;
class BasicCamera {
public:
virtual ~BasicCamera() {};
virtual void OpenCamera() = 0;
};
class Hik :public BasicCamera {
public:
void OpenCamera() {
cout << "打开海康相机" << endl;
}
};
class DaHua :public BasicCamera {
public:
void OpenCamera() {
cout << "打开大华相机" << endl;
}
};
class Factory {
public:
BasicCamera* CreateCamera(string type) {
if (type == "Hik")
return new Hik();
else if (type == "DaHua")
return new DaHua();
else
return NULL;
}
};
int main() {
Factory fac = Factory();
BasicCamera* camera = fac.CreateCamera("Hik");
camera->OpenCamera();
delete camera;
getchar();
return 0;
}
当我们需要增加一类相机时，我们需要先定义一个类继承BasicCamera类，还要修改 Factory 类的代码，增加if else判断。这显然是违背开闭原则的。
Tips：
1. 由于工厂模式会返回一个基类指针，指向新生成的derived类对象，对象位于heap，为避免泄露内存和其他资源，要将返回的对象delete掉。如果前面的基类（BasicCamera）没有virtual的析构函数，那么通常发生的是对象的derived部分没有被销毁，产生局部销毁的现象。因此必须要加
virtual ~BasicCamera() {};
2. 基类生成对象不合理，因此在基类中定义了纯虚函数
virtual void OpenCamera() = 0;
3. UML图
+表示public，函数后面加冒号后面跟着返回类型。
工厂方法模式
#include<iostream>
using namespace std;
class BasicCamera {
public:
virtual ~BasicCamera() {};
virtual void OpenCamera() = 0;
};
class Hik :public BasicCamera {
public:
void OpenCamera() {
cout << "打开海康相机" << endl;
}
};
class DaHua :public BasicCamera {
public:
void OpenCamera() {
cout << "打开大华相机" << endl;
}
};
class Factory {
public:
virtual ~Factory() {}
virtual BasicCamera* CreateCamera() = 0;
};
class HikFactory :public Factory {
BasicCamera* CreateCamera() { return new Hik(); }
};
class DaHuaFactory :public Factory {
DaHua* CreateCamera() { return new DaHua(); }
};
int main() {
Factory* fac = new HikFactory();
BasicCamera* cam = fac->CreateCamera();
cam->OpenCamera();
delete cam;
delete fac;
getchar();
return 0;
}
在以下情况下可以使用工厂方法模式：
- 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
- 一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
- 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。
优点：
- 一个调用者想创建一个对象，只要知道其名称就可以了。
- 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
- 屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
抽象工厂模式
#include<iostream>
using namespace std;
class BasicCamera {
public:
virtual ~BasicCamera() {};
virtual void OpenCamera() = 0;
};
class HikCamera :public BasicCamera {
public:
void OpenCamera() {
cout << "打开海康相机" << endl;
}
};
class BasicLen {
public:
virtual ~BasicLen() {};
virtual void InstallLen() = 0;
};
class HikLen :public BasicLen {
void InstallLen() {
cout << "安装了海康镜头" << endl;
}
};
class Factory {
public:
virtual ~Factory() {};
virtual BasicCamera* CreateCamera() = 0;
virtual BasicLen* CreateLen() = 0;
};
class HikFactory :public Factory {
BasicCamera* CreateCamera() { return new HikCamera(); }
BasicLen* CreateLen() { return new HikLen(); }
};
int main() {
Factory* fac = new HikFactory();
BasicCamera* cam = fac->CreateCamera();
BasicLen* len = fac->CreateLen();
cam->OpenCamera();
len->InstallLen();
delete len;
delete cam;
delete fac;
getchar();
return 0;
}
优点：
- 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易，所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
- 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
- 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。
抽象模板工厂
#include<iostream>
using namespace std;
class BasicCamera {
public:
virtual ~BasicCamera() {};
virtual void OpenCamera() = 0;
};
class HikCamera :public BasicCamera {
public:
void OpenCamera() {
cout << "打开海康相机" << endl;
}
};
class DaHuaCamera :public BasicCamera {
public:
void OpenCamera() {
cout << "打开大华相机" << endl;
}
};
class BasicLen {
public:
virtual ~BasicLen() {};
virtual void InstallLen() = 0;
};
class HikLen :public BasicLen {
void InstallLen() {
cout << "安装了海康镜头" << endl;
}
};
template <class AbstractProduct_t>
class AbstractFactory {
public:
virtual ~AbstractFactory() {};
virtual AbstractProduct_t* CreateProduct() = 0;
};
template <class AbstractProduct_t, class ConcreteProduct_t>
class ConcreteFactory :public AbstractFactory< AbstractProduct_t> {
public:
AbstractProduct_t* CreateProduct() { return new ConcreteProduct_t(); }
};
int main() {
AbstractFactory<BasicCamera>* fac = new ConcreteFactory<BasicCamera, HikCamera>();
AbstractFactory<BasicCamera>* fac1 = new ConcreteFactory<BasicCamera, DaHuaCamera>();
AbstractFactory<BasicLen>* fac2 = new ConcreteFactory<BasicLen, HikLen>();
BasicCamera* cam = fac->CreateProduct();
BasicCamera* cam1 = fac1->CreateProduct();
BasicLen* len = fac2->CreateProduct();
cam->OpenCamera();
cam1->OpenCamera();
len->InstallLen();
delete cam,cam1,len,fac,fac1,fac2;
getchar();
return 0;
}
产品注册模板类+单例工厂模板类
#include<iostream>
#include <map>
using namespace std;
class BasicCamera {
public:
virtual ~BasicCamera() {};
virtual void OpenCamera() = 0;
};
class HikCamera :public BasicCamera {
public:
void OpenCamera() {
cout << "打开海康相机" << endl;
}
};
class DaHuaCamera :public BasicCamera {
public:
void OpenCamera() {
cout << "打开大华相机" << endl;
}
};
class BasicLen {
public:
virtual ~BasicLen() {};
virtual void InstallLen() = 0;
};
class HikLen :public BasicLen {
void InstallLen() {
cout << "安装了海康镜头" << endl;
}
};
// 基类，产品注册模板接口类
// 模板参数 ProductType_t 表示的类是产品抽象类
template <class ProductType_t>
class IProductRegistrar
{
public:
// 获取产品对象抽象接口
virtual ProductType_t* CreateProduct() = 0;
protected:
// 禁止外部构造和虚构, 子类的"内部"的其他函数可以调用
IProductRegistrar() {}
virtual ~IProductRegistrar() {}
private:
// 禁止外部拷贝和赋值操作
IProductRegistrar(const IProductRegistrar&);
const IProductRegistrar& operator=(const IProductRegistrar&);
};
// 工厂模板类，用于获取和注册产品对象
// 模板参数 ProductType_t 表示的类是产品抽象类
template <class ProductType_t>
class ProductFactory
{
public:
// 获取工厂单例，工厂的实例是唯一的
static ProductFactory<ProductType_t>& Instance()
{
static ProductFactory<ProductType_t> instance;
return instance;
}
// 产品注册
void RegisterProduct(IProductRegistrar<ProductType_t>* registrar, std::string name)
{
m_ProductRegistry[name] = registrar;
}
// 根据名字name，获取对应具体的产品对象
ProductType_t* GetProduct(std::string name)
{
// 从map找到已经注册过的产品，并返回产品对象
if (m_ProductRegistry.find(name) != m_ProductRegistry.end())
{
return m_ProductRegistry[name]->CreateProduct();
}
// 未注册的产品，则报错未找到
std::cout << "No product found for " << name << std::endl;
return NULL;
}
private:
// 禁止外部构造和虚构
ProductFactory() {}
~ProductFactory() {}
// 禁止外部拷贝和赋值操作
ProductFactory(const ProductFactory&);
const ProductFactory& operator=(const ProductFactory&);
// 保存注册过的产品，key:产品名字 , value:产品类型
map<string, IProductRegistrar<ProductType_t>*> m_ProductRegistry;
};
// 产品注册模板类，用于创建具体产品和从工厂里注册产品
// 模板参数 ProductType_t 表示的类是产品抽象类（基类），ProductImpl_t 表示的类是具体产品（产品种类的子类）
template <class ProductType_t, class ProductImpl_t>
class ProductRegistrar : public IProductRegistrar<ProductType_t>
{
public:
// 构造函数，用于注册产品到工厂，只能显示调用
explicit ProductRegistrar(std::string name)
{
// 通过工厂单例把产品注册到工厂
ProductFactory<ProductType_t>::Instance().RegisterProduct(this, name);
}
// 创建具体产品对象指针
ProductType_t* CreateProduct()
{
return new ProductImpl_t();
}
};
int main() {
IProductRegistrar<BasicCamera>* reg = new ProductRegistrar<BasicCamera, HikCamera>("camera_Hik");
BasicCamera* cam = ProductFactory<BasicCamera>::Instance().GetProduct("camera_Hik");
cam->OpenCamera();
if (cam) delete cam;
getchar();
return 0;
}
产品注册的对象用std::map的方式保存，通过key-valve的方式可以轻松简单的获取对应的产品对象实例。
Tips：（未完成）
1. Instance
单例模式
2. map
map是STL的一个关联容器，它提供一对一的hash
- 第一个可以称为关键字(key)，每个关键字只能在map中出现一次；
- 第二个可能称为该关键字的值(value)；
参考文献
https://www.cnblogs.com/xiaolincoding/p/11524376.html
https://www.cnblogs.com/xiaolincoding/p/11524401.html
https://www.zhihu.com/question/20367734/answer/1089721250
这篇关于C++笔记（11）工厂模式的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
【机器学习(二)】分类和回归任务-决策树(Decision Tree,DT)算法-Sentosa_DSML社区版11-25
-
增量更新怎么做？-icode9专业技术文章分享11-23
-
压缩包加密方案有哪些？-icode9专业技术文章分享11-23
-
用shell怎么写一个开机时自动同步远程仓库的代码？-icode9专业技术文章分享11-23
-
webman可以同步自己的仓库吗？-icode9专业技术文章分享11-23
-
在 Webman 中怎么判断是否有某命令进程正在运行？-icode9专业技术文章分享11-23
-
如何重置new Swiper?-icode9专业技术文章分享11-23
-
oss直传有什么好处？-icode9专业技术文章分享11-23
-
如何将oss直传封装成一个组件在其他页面调用时都可以使用？-icode9专业技术文章分享11-23
-
怎么使用laravel 11在代码里获取路由列表？-icode9专业技术文章分享11-23
-
怎么实现ansible playbook 备份代码中命名包含时间戳功能？-icode9专业技术文章分享11-22
-
ansible 的archive 参数是什么意思？-icode9专业技术文章分享11-22
-
ansible 中怎么只用archive 排除某个目录？-icode9专业技术文章分享11-22
-
exclude_path参数是什么作用？-icode9专业技术文章分享11-22
-
微信开放平台第三方平台什么时候调用数据预拉取和数据周期性更新接口？-icode9专业技术文章分享11-22
栏目导航
