c++设计模式（抽象工厂模式）

抽象工厂模式：

• 提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类

 

• 这个东西没什么好说的，一般都很熟悉了，直接上代码

#include <iostream>
#include <string>
using namespace std;
/*
抽象工厂模式：

提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类


*/
class AbstractProduct
{
public:
	AbstractProduct() {}
	virtual ~AbstractProduct() {}

	virtual void Func() = 0;
};

class ProductA_1 :public AbstractProduct
{
public:
	ProductA_1() {}
	~ProductA_1() {}

	virtual void Func() override
	{
		cout << "ProductA_1 Func" << endl;
	}

};
class ProductB_1 :public AbstractProduct
{
public:
	ProductB_1() {}
	~ProductB_1() {}

	virtual void Func() override
	{
		cout << "ProductB_1 Func" << endl;
	}

};
class ProductA_2 :public AbstractProduct
{
public:
	ProductA_2() {}
	~ProductA_2() {}

	virtual void Func() override
	{
		cout << "ProductA_2 Func" << endl;
	}

};
class ProductB_2 :public AbstractProduct
{
public:
	ProductB_2() {}
	~ProductB_2() {}

	virtual void Func() override
	{
		cout << "ProductB_2 Func" << endl;
	}

};
class AbstractFactory
{
public:
	AbstractFactory() {}
	virtual ~AbstractFactory() {}
	virtual AbstractProduct* CreatProduct1() = 0;
	virtual AbstractProduct* CreatProduct2() = 0;
};
class FactoryA : public AbstractFactory
{
public:
	FactoryA() {}
	~FactoryA() {}

	virtual AbstractProduct * CreatProduct1() override
	{
		return new ProductA_1;
	}
	virtual AbstractProduct * CreatProduct2() override
	{
		return new ProductA_2;
	}

};
class FactoryB : public AbstractFactory
{
public:
	FactoryB() {}
	~FactoryB() {}

	virtual AbstractProduct * CreatProduct1() override
	{
		return new ProductB_1;
	}
	virtual AbstractProduct * CreatProduct2() override
	{
		return new ProductB_2;
	}

};

int main()
{
	//AbstractFactory *f = new FactoryA;
	AbstractFactory *f = new FactoryB;

	AbstractProduct *p1 = f->CreatProduct1();
	AbstractProduct *p2 = f->CreatProduct2();

	p1->Func();
	p2->Func();

	delete f;
	delete p1;
	delete p2;

	getchar();
	return 0;
}