C++ Factory & AbstractFactory 模式

1.工厂模式（Factory）：

Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现

#include <iostream>
using namespace std;

//抽象类
class Product 
{ 
public: 
	virtual ~Product() =0;
protected: 
	Product();
private:
};

class ConcreteProduct: public Product 
{ 
public: 
	~ConcreteProduct();
	ConcreteProduct();
protected:
private:
};

Product::Product() {}
Product::~Product() {}

ConcreteProduct::ConcreteProduct()
{
	cout<<"ConcreteProduct...."<<endl;
}
ConcreteProduct::~ConcreteProduct(){}

//抽象类
class Factory
{
public:
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;
protected:
	Factory();
private:
};

class ConcreteFactory:public Factory 
{
public:
	~ConcreteFactory();
	ConcreteFactory();
	Product* CreateProduct();
protected:
private:
};
Factory::Factory(){}
Factory::~Factory(){}

ConcreteFactory::ConcreteFactory()
{
	cout<<"ConcreteFactory....."<<endl;
}
ConcreteFactory::~ConcreteFactory() {}
Product* ConcreteFactory::CreateProduct()
{
	return new ConcreteProduct();
}

int main()
{
	Factory* fac = new ConcreteFactory();
	Product* p = fac->CreateProduct();
	return 0;
}

2.抽象工厂模式（Abstract Factory）：

AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口。

#include <iostream>
using namespace std;

//抽象产品类A
class AbstractProductA
{
	public:
		virtual ~AbstractProductA();
	protected:
		AbstractProductA();
	private:
};
//抽象产品类B
class AbstractProductB
{
	public:
		virtual ~AbstractProductB();
	protected:
		AbstractProductB();
	private:
};
//子类A1
class ProductA1:public AbstractProductA
{
	public:
		ProductA1();
		~ProductA1();
	protected:
	private:
};
//子类A2
class ProductA2:public AbstractProductA
{
	public:
		ProductA2();
		~ProductA2();
	protected:
	private:
};
//子类B1
class ProductB1:public AbstractProductB
{
	public:
		ProductB1();
		~ProductB1();
	protected:
	private:
};
//子类B2
class ProductB2:public AbstractProductB
{
	public:
		ProductB2();
		~ProductB2();
protected:
private:
};

AbstractProductA::AbstractProductA(){}
AbstractProductA::~AbstractProductA(){}
AbstractProductB::AbstractProductB(){}
AbstractProductB::~AbstractProductB(){}
ProductA1::ProductA1(){cout<<"ProductA1..."<<endl;}
ProductA1::~ProductA1(){}
ProductA2::ProductA2(){cout<<"ProductA2..."<<endl;}
ProductA2::~ProductA2(){}
ProductB1::ProductB1(){cout<<"ProductB1..."<<endl;}
ProductB1::~ProductB1() {}
ProductB2::ProductB2(){cout<<"ProductB2..."<<endl;}
ProductB2::~ProductB2() {}

//抽象工厂类
class AbstractFactory
{
	public:
		virtual ~AbstractFactory();
		virtual AbstractProductA* CreateProductA() = 0;
		virtual AbstractProductB* CreateProductB() = 0;
	protected: AbstractFactory();
	private:
};
//工厂子类ConcreteFactory1，用于生产产品A1,B1
class ConcreteFactory1:public AbstractFactory
{
	public:
		ConcreteFactory1();
		~ConcreteFactory1();
		AbstractProductA* CreateProductA();
		AbstractProductB* CreateProductB();
	protected:
	private:
};
//工厂子类ConcreteFactory2，用于生产产品A2,B2
class ConcreteFactory2:public AbstractFactory
{
	public:
		ConcreteFactory2();
		~ConcreteFactory2();
		AbstractProductA* CreateProductA();
		AbstractProductB* CreateProductB();
	protected:
	private:
};
AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}
ConcreteFactory1::ConcreteFactory1(){}
ConcreteFactory1::~ConcreteFactory1(){}
AbstractProductA* ConcreteFactory1::CreateProductA()
{
	return new ProductA1();
}
AbstractProductB* ConcreteFactory1::CreateProductB()
{
	return new ProductB1();
}
ConcreteFactory2::ConcreteFactory2(){}
ConcreteFactory2::~ConcreteFactory2(){}
AbstractProductA* ConcreteFactory2::CreateProductA()
{
	return new ProductA2();
}
AbstractProductB* ConcreteFactory2::CreateProductB()
{
	return new ProductB2();
}

int main()
{
	AbstractFactory* cf1 = new ConcreteFactory1();
	cf1->CreateProductA();
	cf1->CreateProductB();
	cout<<endl;
	AbstractFactory* cf2 = new ConcreteFactory2();
	cf2->CreateProductA();
	cf2->CreateProductB();
	return 0;
}