c++ 创建型模式-抽象工厂(Abstract_Factory)

抽象工厂模式

1) 意图：

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体的类。(这里强调一系列，这是抽象工厂和工厂模式的主要区别，工厂模式工厂类和产品种类是一一对应的，而抽象工厂则可以创建多种相关或相互依赖的一系列产品)

2) 结构:

 

 

　　其中：

　　　　AbstractFactory为创建抽象产品对象声明的工厂接口

　　　　ConcreteFactory实现创建具体产品对象的工厂

　　　　AbstractProduct为一类产品对象声明一个产品接口

　　　　Product定义一个具体的产品对象

　　　　Client只使用由AbstractFactory和AbstractProduct声明的接口

3) 适用性：

　　a. 一个系统要独立于它的产品的创建、组合和表示

　　b. 一个系统要由多个产品系列中的一个来配置

　　c. 当要强调一系列相关的产品对象的设计以便进行联合使用

　　d. 当提供一个产品类库，只想显示它们的接口而不是实现时

4) 举例：

#include <iostream>
class AbstractProductA
{
public:
AbstractProductA() {}
virtual ~AbstractProductA() {}
};
class ProductA1 : public AbstractProductA
{
public:
ProductA1()
{
std::cout << "ProductA1" << std::endl;
}
virtual ~ProductA1()
{
std::cout << "~ProductA1" << std::endl;
}
};
class ProductA2 : public AbstractProductA
{
public:
ProductA2()
{
std::cout << "ProductA2" << std::endl;
}
virtual ~ProductA2()
{
std::cout << "~ProductA2" << std::endl;
}
};
class AbstractProductB
{
public:
AbstractProductB() {}
virtual ~AbstractProductB() {}
};
class ProductB1 : public AbstractProductB
{
public:
ProductB1()
{
std::cout << "ProductB1" << std::endl;
}
virtual ~ProductB1()
{
std::cout << "~ProductB1" << std::endl;
}
};
class ProductB2 : public AbstractProductB
{
public:
ProductB2()
{
std::cout << "ProductB2" << std::endl;
}
virtual ~ProductB2()
{
std::cout << "~ProductB2" << std::endl;
}
};


class AbstractFactory
{
public:
AbstractFactory() {}
virtual ~AbstractFactory() {}
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};
class ConcreateFactory1 : public AbstractFactory
{
public:
virtual AbstractProductA* CreateProductA()
{
return new ProductA1();
}
virtual AbstractProductB* CreateProductB()
{
return new ProductB1();
}
};
class ConcreateFactory2 : public AbstractFactory
{
public:
virtual AbstractProductA* CreateProductA()
{
return new ProductA2();
}
virtual AbstractProductB* CreateProductB()
{
return new ProductB2();
}
};

int main()
{
// 生产第1种AB产品
AbstractFactory* factory1 = new ConcreateFactory1();
AbstractProductA* productA1 = factory1->CreateProductA();
AbstractProductB* productB1 = factory1->CreateProductB();

// 生产第2种AB产品
AbstractFactory* factory2 = new ConcreateFactory2();
AbstractProductA* productA2 = factory1->CreateProductA();
AbstractProductB* productB2 = factory1->CreateProductB();

delete factory1;
delete productA1;
delete productB1;
delete factory2;
delete productA2;
delete productB2;
system("pause");
}