设计模式 C++抽象工厂模式

Posted 2021-06-19 WhiteShirtI

推荐阅读设计模式 C++工厂方法模式
品牌知名度逐渐提高，不单单只生产一种产品，如果我们继续使用一个工厂对应一种产品，那么假如有三个品牌华为、小米、苹果。他们各自都要三种产品，分别为手机、耳机、笔记本电脑。则此时我们需要创建9个工厂才能实现，类多了代码的实现和维护起来也是非常麻烦的。此时我们就必须引入一种新的模式----抽象方法模式

此时需要引用两个概念
产品等级：同一产品不同产商
产品族：同一产商不同产品

定义思想：抽象工厂模式是工厂方法模式的泛化版，工厂方法模式是一种特殊的抽象工厂模式。在工厂方法模式中，每一个具体工厂只能生成一种具体产品，而在抽象工厂方法模式中，每一个具体工厂可以生成多个具体产品。在实际的软件开发中，抽象工厂模式使用频率较高

优点：

1. 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”
2. 抽象工厂模式可以实现高内聚，低耦合的设计目的

缺点：

1. 在添加新的产品等级结构时，需要修改所有的工厂角色，包括抽象工厂类，在所有具体工厂类中都需要添加新产品的函数，不能很好的支持“开闭原则”

使用场景：

1. 当需要创建产品家族，或者想让制造的相关产品集合起来
2. 用户不关心对象的创建过程，将对象的创建和使用解耦合

在抽象工厂模式中，我们可以根据厂商不同来创建不同的工厂，每种工厂中都可以生产属于自己的产品


代码实现：
先实现一个抽象类的手机

//抽象手机
class AbstractPhone
{
public:
	virtual void ShowName() = 0;
};

然后所有厂商的手机都要重写抽象手机提供的函数

//华为手机
class HuaweiPhone : public AbstractPhone
{
public:
	virtual void ShowName()
	{
		cout << "华为手机" << endl;
	}
};
//小米手机
class XiaomiPhone : public AbstractPhone
{
public:
	virtual void ShowName()
	{
		cout << "小米手机" << endl;
	}
};
//苹果手机
class ApplePhone : public AbstractPhone
{
public:
	virtual void ShowName()
	{
		cout << "苹果手机" << endl;
	}
};

依次类推，有多少个产品，就需要创建多少个抽象的产品，也对应这每个厂商都需要去重写对应的函数

//抽象耳机
class AbstractHeadset
{
public:
	virtual void ShowName() = 0;
};

//华为耳机
class HuaweiHeadset : public AbstractHeadset
{
public:
	virtual void ShowName()
	{
		cout << "华为耳机" << endl;
	}
};

//小米耳机
class XiaomiHeadset : public AbstractHeadset
{
public:
	virtual void ShowName()
	{
		cout << "小米耳机" << endl;
	}
};

//苹果耳机
class AppleHeadset : public AbstractHeadset
{
public:
	virtual void ShowName()
	{
		cout << "小苹果耳机" << endl;
	}
};

//抽象电脑
class AbstractComputer
{
public:
	virtual void ShowName() = 0;
};

//华为电脑
class HuaweiComputer : public AbstractComputer
{
public:
	virtual void ShowName()
	{
		cout << "华为电脑" << endl;
	}
};

//小米电脑
class XiaomiComputer : public AbstractComputer
{
public:
	virtual void ShowName()
	{
		cout << "小米电脑" << endl;
	}
};

//苹果电脑
class AppleComputer : public AbstractComputer
{
public:
	virtual void ShowName()
	{
		cout << "苹果电脑" << endl;
	}
};

产品有了，此时需要创建一个抽象的工厂，指定具体工厂都要拥有哪些功能

//抽象工厂 针对产品族
class AbstrackFactory
{
public:
	virtual AbstractPhone* CreatePhone() = 0;
	virtual AbstractHeadset* CreateHeadset() = 0;
	virtual AbstractComputer* CreateComputer() = 0;
}

对应的是每个产商都要有每个各自的工厂，并且具体工厂中都要重写抽象工厂的函数

//华为工厂
class HuaweiFactory : public AbstrackFactory
{
public:
	virtual AbstractPhone* CreatePhone()
	{
		return new HuaweiPhone();
	}
	virtual AbstractHeadset* CreateHeadset()
	{
		return new HuaweiHeadset();
	}
	virtual AbstractComputer* CreateComputer()
	{
		return new HuaweiComputer();
	}
};

//小米工厂
class XiaomiFactory : public AbstrackFactory
{
public:
	virtual AbstractPhone* CreatePhone()
	{
		return new XiaomiPhone();
	}
	virtual AbstractHeadset* CreateHeadset()
	{
		return new XiaomiHeadset();
	}
	virtual AbstractComputer* CreateComputer()
	{
		return new XiaomiComputer();
	}
};

//苹果工厂
class AppleFactory : public AbstrackFactory
{
public:
	virtual AbstractPhone* CreatePhone()
	{
		return new ApplePhone();
	}
	virtual AbstractHeadset* CreateHeadset()
	{
		return new AppleHeadset();
	}
	virtual AbstractComputer* CreateComputer()
	{
		return new AppleComputer();
	}
};

测试：

void test()
{
	//创建一个工厂
	AbstrackFactory* factory = nullptr;
	//创建产品
	AbstractPhone* phone = nullptr;
	AbstractHeadset* headset = nullptr;
	AbstractComputer* computer = nullptr;

	//指定该工厂是华为工厂
	factory = new HuaweiFactory();
	//通过华为工厂创建的产品
	phone = factory->CreatePhone();
	headset = factory->CreateHeadset();
	computer = factory->CreateComputer();
	
	phone->ShowName();
	headset->ShowName();
	computer->ShowName();

	delete phone;
	delete headset;
	delete computer;
	delete factory;
}