策略模式+简单工厂

🍇工厂模式
🍈工厂模式向策略模式过度——工厂加一个保安
🍏策略模式
🍐策略模式+简单工厂

声明本文需要理解多态的基础上才能来学习
欢迎前来学习——继承和多态
学习记录

工厂模式

需要什么就生成什么

// 工厂模式
class Factory
{
	// 这个是工厂
public:
	Factory()
	{
		puts("Factory");
	}
	//virtual void func() = 0;// 不能使用纯虚函数，使用纯虚函数就不能在工厂中创建对象
	// virtual void func();// 也不能只声明不定义
	virtual void func()
	{}
};
class FactoryA :public Factory
{
public:
	FactoryA()
	{
		puts("FactoryaA");
	}
	void func()
	{
		puts("funcA");
	}
};
class FactoryB :public Factory
{
public:
	FactoryB()
	{
		puts("FactoryB");
	}
	void func()
	{
		puts("funcB");
	}
};

int main()
{
	FactoryA a;
	a.func();
	FactoryB b;
	b.func();

	return 0;
}

问： 看了代码上面的内容之后，我就想问，都要写3个类了，为什么不直接实现成3个毫无关系的类呢，为什么要实现成多态的形式，多麻烦呀

答： 话是这么说没错，但是，让他们没有联系，如果有100个类，他们需要进行改动，需要添加一个函数，那么就需要改动100次；而如果使用继承，就可以大大减少工作量

工厂模式向策略模式过度——工厂加一个保安

class Factory
{
	// 这个是工厂
public:
	Factory()
	{
		puts("Factory");
	}
	//virtual void func() = 0;// 不能使用纯虚函数，使用纯虚函数就不能在工厂中创建对象
	// virtual void func();// 也不能只声明不定义
	virtual void func()
	{}
};
class FactoryA :public Factory
{
public:
	FactoryA()
	{
		puts("FactoryaA");
	}
	void func()
	{
		puts("funcA");
	}
};
class FactoryB :public Factory
{
public:
	FactoryB()
	{
		puts("FactoryB");
	}
	void func()
	{
		puts("funcB");
	}
};
class Context
{
	// 这个是将产品给他管理
public:
	Context()
	{
		puts("Context");
	}
	// 这里需要实现多态，不同的产品有不同的行为
	Context(Factory* tem)
	{
		s = tem;
		puts("Context");
	}
	void Interface()
	{
		s->func();
	}
	Factory* s;
};

好处就在于使用者就可以忽略多态这个特性直接向平常的函数一样使用就可以了

策略模式

策略模式：在用户使用的时候手动进行判断，判断需要使用哪个产品进行生产

策略模式+简单工厂

策略模式+工厂模式就是为了解决需要手动判断的问题——降低使用难度，简化使用步骤

具体实现就是将判断的逻辑放到Context内部

#include<iostream>
using namespace std;

// 策略模式+工厂模式
class Strategy
{
	// 这个是工厂
public:
	Strategy()
	{
		puts("Strategy");
	}
	//virtual void func() = 0;// 不能使用纯虚函数，使用纯虚函数就不能在工厂中创建对象
	// virtual void func();// 也不能只声明不定义
	virtual void func()
	{}
};
class StrategyA :public Strategy
{
public:
	StrategyA()
	{
		puts("StrategyA");
	}
	void func()
	{
		puts("funcA");
	}
};
class StrategyB :public Strategy
{
public:
	StrategyB()
	{
		puts("StrategyB");
	}
	void func()
	{
		puts("funcB");
	}
};
class Context
{
	// 这个是将产品给他管理
public:
	Context()
	{
		puts("Context");
	}
	// 这里需要实现多态，不同的产品有不同的行为
	//Context(Strategy* tem)
	//{
	//	s = tem;
	//	puts("Context");
	//}
	Context(int t)
	{
		switch (t)
		{
		case 0:
			s = new StrategyA;
			break;
		case 1:
			s = new StrategyB;
			break;
		}
	}
	void Interface()
	{
		s->func();
	}
	Strategy* s;
};

int main()
{
	Context con(1);
	con.Interface();

	return 0;
}

这种方式能让代码更美观