c++之工厂方法模式

定义:

工厂方法模式属于创建型模式,用于定义一个用于创建对象的接口,让子类决定实例化哪一个类,即将实际创建工作推迟到子类当中进行。

它的核心角色有4个,分别是抽象工厂以及具体工厂,抽象产品以及具体产品。

类图:

通过类图可知,工厂方法即一个抽象工厂对应一个抽象产品,一个具体工厂对应一个具体产品,而这个具体的工厂就只负责生产对应的产品。

工厂方法模式完全符合开发封闭原则,扩展性强。

应用场景:

假设我们想生产啤酒和白酒,可以考虑新建一个啤酒工厂和一个白酒工厂,然后把这两个工厂的共同点抽象出来,即抽象工厂类

,把啤酒和白酒的共同点抽象出来,即酒类。为什么要抽象出来呢,一是便于接下来复用抽象类,可能我们后面还需要一个生产红酒,就可以让红酒类继承抽象酒类,

红酒工厂继承抽象工厂类,可以减少相同的代码量,二是可以用抽象类指针实现不同子类的接口,实现多态,便于后期扩展和维护代码。

代码:

#include <iostream>

using namespace std;

//抽象产品
class IWine
{
public:
	virtual ~IWine() {}
	virtual void createWine() = 0;
};

//抽象工厂类
class IFactory
{
public:
	virtual ~IFactory() {}
	virtual IWine* createFactory() = 0;
};

//啤酒-具体产品
class Beer :public IWine
{
public:
	void createWine()
	{
		cout << "生产啤酒" << endl;
	}
};

//白酒-具体产品
class Spirit :public IWine
{
public:
	void createWine()
	{
		cout << "生产白酒" << endl;
	}
};


//啤酒工厂-生产啤酒
class BeerFactory :public IFactory
{
public:
	IWine* createFactory()
	{
		return new Beer;
	}
};

//白酒工厂-生产白酒
class SpiritFactory :public IFactory
{
public:
	IWine* createFactory()
	{
		return new Spirit;
	}
};


int main()	//客户端
{
	IFactory *factory = new BeerFactory;
	//IFactory *factory = new SpiritFactory;
	factory->createFactory()->createWine();

	if (factory) delete factory;

	getchar();

	return 0;
}

输出:

 

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
抽象工厂方法模式(Abstract Factory Pattern)是一种创建型设计模式,它提供了一个接口,用于创建一系列相关或依赖对象的家族,而无需指定它们具体的类。 在 C++ 中,抽象工厂方法模式通常通过定义一个抽象基类来实现。这个抽象基类定义了一系列纯虚函数,用于创建不同类型的产品对象。然后,针对不同的产品族,创建具体的工厂类,这些工厂类实现了抽象基类中定义的纯虚函数,用于创建具体的产品对象。 以下是一个简单的抽象工厂方法模式的示例代码: ```c++ // 抽象产品类 A class AbstractProductA { public: virtual void operationA() = 0; }; // 抽象产品类 B class AbstractProductB { public: virtual void operationB() = 0; }; // 具体产品类 A1 class ConcreteProductA1 : public AbstractProductA { public: void operationA() { std::cout << "ConcreteProductA1::operationA()" << std::endl; } }; // 具体产品类 A2 class ConcreteProductA2 : public AbstractProductA { public: void operationA() { std::cout << "ConcreteProductA2::operationA()" << std::endl; } }; // 具体产品类 B1 class ConcreteProductB1 : public AbstractProductB { public: void operationB() { std::cout << "ConcreteProductB1::operationB()" << std::endl; } }; // 具体产品类 B2 class ConcreteProductB2 : public AbstractProductB { public: void operationB() { std::cout << "ConcreteProductB2::operationB()" << std::endl; } }; // 抽象工厂类 class AbstractFactory { public: virtual AbstractProductA* createProductA() = 0; virtual AbstractProductB* createProductB() = 0; }; // 具体工厂类 1 class ConcreteFactory1 : public AbstractFactory { public: AbstractProductA* createProductA() { return new ConcreteProductA1(); } AbstractProductB* createProductB() { return new ConcreteProductB1(); } }; // 具体工厂类 2 class ConcreteFactory2 : public AbstractFactory { public: AbstractProductA* createProductA() { return new ConcreteProductA2(); } AbstractProductB* createProductB() { return new ConcreteProductB2(); } }; int main() { AbstractFactory* factory1 = new ConcreteFactory1(); AbstractProductA* productA1 = factory1->createProductA(); AbstractProductB* productB1 = factory1->createProductB(); productA1->operationA(); // 输出:ConcreteProductA1::operationA() productB1->operationB(); // 输出:ConcreteProductB1::operationB() AbstractFactory* factory2 = new ConcreteFactory2(); AbstractProductA* productA2 = factory2->createProductA(); AbstractProductB* productB2 = factory2->createProductB(); productA2->operationA(); // 输出:ConcreteProductA2::operationA() productB2->operationB(); // 输出:ConcreteProductB2::operationB() return 0; } ``` 在上面的示例代码中,我们定义了两个抽象产品类 `AbstractProductA` 和 `AbstractProductB`,以及四个具体产品类 `ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1` 和 `ConcreteProductB2`。然后,我们定义了一个抽象工厂类 `AbstractFactory`,它包含两个纯虚函数,用于创建不同类型的产品对象。最后,我们定义了两个具体工厂类 `ConcreteFactory1` 和 `ConcreteFactory2`,它们分别实现了 `AbstractFactory` 中定义的纯虚函数,用于创建具体的产品对象。 在 `main` 函数中,我们首先创建了一个 `ConcreteFactory1` 对象,然后使用它创建了一个 `ConcreteProductA1` 和一个 `ConcreteProductB1` 对象,并调用了它们的成员函数。然后,我们创建了一个 `ConcreteFactory2` 对象,使用它创建了一个 `ConcreteProductA2` 和一个 `ConcreteProductB2` 对象,并调用了它们的成员函数。 通过这种方式,我们可以轻松地创建一系列相关或依赖对象的家族,并且无需指定它们具体的类。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值