简单工厂,工厂方法 和 抽象工厂

这三种模式， 都是创建类型的模式， 将对象的创建流程封装起来供客户调用

简单工厂模式

简介: 和策略模式一样，就是针对不通的参数， 返回不通的实例而已
问题: 没有遵循开闭原则， 如果我们想增加一种类， 那么就要修改工厂的核心代码，这违反了对修改关闭的原则, 于是有了 工厂方法模式

策略模式和简单工厂模式的代码用例

class Operator
{
public:
	int first, second;
	Operator() {};
	Operator(int a, int b) : first(a), second(b) {};
	virtual int get_result() = 0;
};


class AddOperator : public Operator
{
public:
	AddOperator() {};
	AddOperator(int a, int b) : Operator(a, b) {};
	int get_result() override
	{
		return first + second;
	}
};

class MulOperator : public Operator
{
public:
	MulOperator() {};
	MulOperator(int a, int b) : Operator(a, b) {};
	int get_result() override
	{
		return first * second;
	}
};


// strategy
int get_result(char _type, int a, int b)
{
	Operator* o{};
	if (_type == '+')
		o = new AddOperator(a, b);
	if (_type == '*')
		o = new MulOperator(a, b);
	return o->get_result();
}

// simple factory
class OperatorFactory
{
public:
	Operator* get_operator(char c)
	{
		Operator* o{};
		if (c == '+')
			o = new AddOperator();
		if (c == '*')
			o = new MulOperator();
		return o;
	}
};

int main()
{
	//策略模式
	int a = get_result('+', 1, 2);
	cout << a << endl;
	int b = get_result('*', 8, 9);
	cout << b << endl;

	// 简单工厂模式
	OperatorFactory* op_factory = new OperatorFactory();
	Operator* o = op_factory->get_operator('+');
	o->first = 1;
	o->second = 2;
	cout << o->get_result() << endl;
}

工厂方法模式

简介: 在简单工厂的基础上，遵循开闭原则, 每个工厂都只产出自己的类， 那么再有新的类要加入的时候， 我们只需要添加一个工厂子类 和 目标子类就行了
问题: 工厂只能产出一种目标类的实例, 这样的话, 系统中类一多, 工厂就会太多.
`代码``

class Operator
{
public:
	int first, second;
	Operator() {};
	Operator(int a, int b) : first(a), second(b) {};
	virtual int get_result() = 0;
};


class AddOperator : public Operator
{
public:
	AddOperator() {};
	AddOperator(int a, int b) : Operator(a, b) {};
	int get_result() override
	{
		return first + second;
	}
};

class MulOperator : public Operator
{
public:
	MulOperator() {};
	MulOperator(int a, int b) : Operator(a, b) {};
	int get_result() override
	{
		return first * second;
	}
};

class Factory
{
public:
	virtual Operator* get_operator(int a, int b) = 0;
};


class AddFactory : public Factory
{
public:
	Operator* get_operator(int a, int b) override
	{
		Operator* op = new AddOperator(a, b);
		return op;
	}
};


class MulFactory : public Factory
{
public:
	Operator* get_operator(int a, int b) override
	{
		Operator* op = new MulOperator(a, b);
		return op;
	}
};

int main()
{
	// 工厂方法模式
	AddFactory* add_f = new AddFactory();
	Operator* op = add_f->get_operator(1, 2);
	cout << op->get_result() << endl;
}

抽象工厂模式

简介: 一个工厂产出一系列互相关联的类的实例, 实现产品簇的效果
代码

class SoftWare
{
public:
	SoftWare() {};
};


class AndroidSoftWare : public SoftWare
{
public:
	AndroidSoftWare() {};
};


class IosSoftWare : public SoftWare
{
public:
	IosSoftWare() {};
};


class Phone
{
public:
	SoftWare* ware;
	virtual void set_soft_ware(SoftWare* ware) = 0;
};


class XiaoMiPhone : public Phone
{
public:
	void set_soft_ware(SoftWare* w) override
	{
		cout << "xiao mi phone set android soft ware" << endl;
		ware = w;
	}
};

class IosPhone : public Phone
{
public:
	void set_soft_ware(SoftWare* w) override
	{
		cout << "ios phone set ios soft ware" << endl;
		ware = w;
	}
};


// 这种情况下, 用抽象工厂模式, 就不会出错, 不会出现iosphone配上了android soft ware的情况
// 不然在实际项目中, 配错很可能会出现严重后果
class AbstractFactory
{
public:
	virtual Phone* create_phone() = 0;
	virtual SoftWare* create_soft_ware() = 0;
};


class XiaoMiFactory : public AbstractFactory
{
	Phone* create_phone() override
	{
		Phone* p = new XiaoMiPhone();
		return p;
	}
	SoftWare* create_soft_ware() override
	{
		SoftWare* sw = new AndroidSoftWare();
		return sw;
	}
};


class IosFactory : public AbstractFactory
{
	Phone* create_phone() override
	{
		Phone* p = new IosPhone();
		return p;
	}
	SoftWare* create_soft_ware() override
	{
		SoftWare* sw = new IosSoftWare();
		return sw;
	}
};
int main()
{
	// 很多情况下, 工厂不止是生产一种类, 而是生产一整套互相关联的类, 这样一个工厂, 就是抽象工厂模式
	AbstractFactory* af = new XiaoMiFactory();
	Phone* p1 = af->create_phone();
	SoftWare* sw = af->create_soft_ware();
	p1->set_soft_ware(sw);

	af = new IosFactory();
	Phone* p2 = af->create_phone();
	SoftWare* sw2 = af->create_soft_ware();
	p2->set_soft_ware(sw2);
}