设计模式之工厂模式(简单工厂模式，工厂方法，抽象工厂)，使用c++实现工厂模式

目录

1.概述

2.简单工厂模式

3.工厂方法模式

4.抽象工厂模式

5.工厂模式的实际应用

               

---

1.概述

工厂模式是对c++多态性质的充分使用，通过同一个基类指针能调用不同的实列化对象。

优势：很好的遵循了开放-封闭的原则，对内程序内的修改是封闭的，对基类的派生类的扩展开放是允许的。如果有新的需求，只需要继承基类，增加新的派生类就可以了。减少了项目更新的时候

对项目代码修改的数量，通过新增派生类就可以解决问题

工厂模式总共有三种，简单工厂模式，工厂方法模式，抽象工厂模式三种，在接下来的内容中会分别对三种模式进行介绍，介绍模式是这样的，简单叙述+uml类关系图+实例代码。本文主要参考了<<大话设计模式>>一书

2.简单工厂模式

简单工厂模式主要有，产品基类，产品派生类，工厂类，通过工厂类生产需要的实例化产品对象

对应的uml图

对应的代码如下

stdafx.h文件

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

enum OprationType
{
	type_add,
	type_sub,
	type_mul,
	type_div

};

opration.h文件

#pragma once
class Opration
{
public:
	Opration(){};
	virtual ~Opration(){};
public:

	virtual int  GetResult(int a, int b) { return 0; };
	
};

factory.h文件

#pragma once
#include "stdafx.h"
#include "opration.h"
#include "opration_object.h"
#include <iostream>
class OprationFactory {
public:
	OprationFactory() {};
	 ~OprationFactory() {};
public:
	std::shared_ptr<Opration> CreateOpration(OprationType type) {

		switch (type)
		{
		case type_add:
			return  std::make_shared<AddOpration>();
		case type_sub:
			return  std::make_shared<SubOpration>();
		case type_mul:
			return  std::make_shared<MulOpration>();
		case type_div:
			return  std::make_shared<DivOpration>();
		default:
			break;
		}
	 }
};

opration_object.h文件

#pragma once
#include "stdafx.h"
#include "opration.h"

class AddOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a + b;
	}
};

class SubOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a - b;
	}
};


class MulOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a * b;
	}
};

class DivOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a / b;
	}
};

myproject.cpp文件

#include "stdafx.h"
#include "opration.h"
#include "factory.h"
#include <iostream>
#include <memory>
int main()
{
	std::shared_ptr<OprationFactory> fac = std::make_shared<OprationFactory>();
	std::shared_ptr<Opration> add_opration = fac->CreateOpration(OprationType::type_add);
	std::shared_ptr<Opration> sub_opration = fac->CreateOpration(OprationType::type_sub);
	
	

	int a = add_opration->GetResult(4, 3);
	int b = sub_opration->GetResult(4, 3);
	printf("a的值%d\n",a);
	printf("b的值%d\n", b);
    return 0;
}

3.工厂方法模式

工厂方法模式对比简单工厂模式，怎加了一个优势就是，如果后面你要增加一个求m的n次方的方法，你还要去修改工厂类，在switch case 里面增加一种方法。工厂方法模式很好的解决了这个问题。

工厂方法模式主要有，产品基类，工厂基类，产品派生类，工厂派生类，不同工厂生产不同的产品

uml图

详细代码

stdafx.h文件

#pragma once
#include <iostream>
#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

factory.h文件

#pragma once
#include "stdafx.h"
#include "opration.h"
class OprationFactory {
public:
	OprationFactory() {};
	virtual ~OprationFactory() {};
public:
	virtual std::shared_ptr<Opration>  CreateOpration() =0;
};

factory_opartion.h文件

#include "stdafx.h"
#include "factory.h"
#include "opration_object.h"
class AddFactory :public OprationFactory
{
public:
	std::shared_ptr<Opration>  CreateOpration()
	{
		return std::make_shared<AddOpration>();
	}
};

class SubFactory :public OprationFactory
{
public:
	std::shared_ptr<Opration> CreateOpration()
	{
		return std::make_shared<SubOpration>();
	}
};




class MulFactory :public OprationFactory
{
public:
	std::shared_ptr<Opration>  CreateOpration()
	{
		return std::make_shared<MulOpration>();
	}
};


class DivFactory :public OprationFactory
{
public:
	std::shared_ptr<Opration>  CreateOpration()
	{
		return std::make_shared<DivOpration> ();
	}
};

opration.h文件

#pragma once
class Opration
{
public:
	Opration();
	virtual ~Opration();
public:

	virtual int  GetResult(int a, int b) { return 0; };
	
};

opration_object.h文件

#pragma once
#include "stdafx.h"
#include "opration.h"

class AddOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a + b;
	}
};

class SubOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a - b;
	}
};


class MulOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a * b;
	}
};

class DivOpration :public Opration
{
public:
	int GetResult(int a, int b) {
		return a / b;
	}
};

myproject.cpp文件

#include "stdafx.h"
#include "factory_opartion.h"
#include "opration.h"
#include <iostream>
#include <memory>
int main()
{
	
	std::shared_ptr<OprationFactory> add_fac = std::make_shared<AddFactory>();
	std::shared_ptr<OprationFactory> sub_fac = std::make_shared<SubFactory>();
	std::shared_ptr<Opration>    addnum = add_fac->CreateOpration();
	std::shared_ptr<Opration>    subnum = sub_fac->CreateOpration();
	int a = addnum->GetResult(4, 3);
	int b = subnum->GetResult(4, 3);
	printf("a的值%d\n",a);
	printf("b的值%d\n", b);
	
    return 0;
}

4.抽象工厂模式

抽象工厂模式主和工厂模式的区别是，抽象工厂模式的工厂类里面，一个工厂类能生产多种产品，

而工厂方法模式一个工厂只能生产一种产品。这是为了应对在项目开发的过程中，产品类型的增多而产生的设计模式

现在在我们的Demo里面只有整形类型的四则运算，现在增加一个需求，针对浮点型的四则运算。

这个例子不一定恰当，只是为了对抽象工厂模式进行说明。

uml

 对应的代码，读者可以根据详细的uml图进行扩展。

5.工厂模式的实际应用

笔者在项目中使用的最多的就是对不同协议进行分派和派发。不同的协议作为一个个的产品，

还有就是类似这种，打折，四则运算，不同数据库....这种类似的场景，读者有其他的思考也可以一起讨论，哈哈。