《大话设计模式》c++实现 抽象工厂模式

为了更清晰地理解工厂方法模式，需要先引入两个概念：

• 产品等级结构 ：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
• 产品族 ：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

抽象工厂模式包含如下角色：

• AbstractFactory：抽象工厂
• ConcreteFactory：具体工厂
• AbstractProduct：抽象产品
• Product：具体产品

在上例中，产品族包括两个：1和2，也就是Sqlserver数据库和Access数据库。

每个产品族里面又包含两类产品：A和B，也就是User表和Department表。

而每个产品族中的产品要一起使用，就是说产品族1中的两类产品A和B要一起使用，也就是说在SqlServer数据库中SqlServerUser表和SqlServerDepartment表要一起使用，Access数据库同理。

工厂角度：

SqlFactory：

　　User：

　　　　//具体产品A1 SqlProductA

　　Department：

　　　　//具体产品B1 SqlProductB
 AccessFactory:

　　User：　　　　

　　　　//具体产品A2 AccessProductA

　　Department：

　　　　//具体产品B2 AccessProductB

产品角度：

AbstractProductA（user 表）:

　　//具体产品A1 SqlProductA

　　//具体产品A2 AccessProductA

AbstractProductB（Department表）

　　

　   //具体产品B1 SqlProductA

　　//具体产品B2 AccessProductA

 #include<string>
 #include<iostream>

 //数据库表项：User  与工厂模式无关
 class User
 {
 private:
     int id;
     std::string name;
 public:
     int getID()
     {
         return id;
     }
     std::string getName()
     {
         return name;
     }
     void setID(int ID)
     {
         this->id = ID;
     }
     void setName(std::string NAME)
     {
         this->name = NAME;
     }
 };

 //数据库表项：Department 与工厂模式无关
 class Department
 {
 private:
     int id;
     std::string name;
 public:
     int getID()
     {
         return id;
     }
     std::string getName()
     {
         return name;
     }
     void setID(int ID)
     {
         this->id = ID;
     }
     void setName(std::string NAME)
     {
         this->name = NAME;
     }
 };

 //抽象产品A:IUser
 class AbstractProductA{
 public:
     virtual void  Insert(User user) = ;
     virtual User* GetUser(int id) = ;
 };

 //具体产品A1 SqlProductA
 class SqlProductA :public AbstractProductA{
 public:
     void  Insert(User user){
         std::cout << "在SQL Server中给User表增加了一条记录" << std::endl;
     }
     User*  GetUser(int id){
         std::cout << "在SQL Server中得到id为:"<<id<<" User表一条记录" << std::endl;
         return NULL;
     }
 };
 //具体产品A2 AccessProductA
 class AccessProductA :public AbstractProductA{
 public:
     void  Insert(User user){
         std::cout << "在Access中给User表增加了一条记录" << std::endl;
     }
     User*  GetUser(int id){
         std::cout << "在Access中得到id为:" << id << " User表一条记录" << std::endl;
         return NULL;
     }
 };

 //抽象产品B：IDepartment
 class AbstractProductB{
 public:
     virtual void  Insert(Department department) = ;
     virtual  Department* GetDepartment(int id) = ;
 };

 //具体产品B1 SqlProductB
 class SqlProductB :public AbstractProductB{
 public:
     void  Insert(Department department){
         std::cout << "在SQL Server中给department表增加了一条记录" << std::endl;
     }
      Department* GetDepartment(int id){
         std::cout << "在SQL Server中得到id为:" << id << " Department表一条记录" << std::endl;
         return NULL;
      }
 };

 //具体产品B2 AccessProductB
 class AccessProductB :public AbstractProductB{
 public:
     void  Insert(Department department){
         std::cout << "在Access中给department表增加了一条记录" << std::endl;
     }
     Department*  GetDepartment(int id){
         std::cout << "在Access中得到id为:" << id << " Department表一条记录" << std::endl;
         return NULL;
     }
 };

 class AbstractFactory{
 public:
     virtual AbstractProductA* createProductA() = ;
     virtual AbstractProductB* createProductB() = ;
 };

 //具体工厂1：SqlServerFactory
 class SqlFactory :public AbstractFactory
 {
 public:
     AbstractProductA* createProductA()
     {
         return new SqlProductA;
     }
     AbstractProductB* createProductB()
     {
         return new SqlProductB;
     }
 };

 //具体工厂2：AccessFactory
 class AccessFactory :public AbstractFactory{
 public:
     AbstractProductA* createProductA()
     {
         return new AccessProductA;
     }
     AbstractProductB* createProductB()
     {
         return new AccessProductB;

     }
 };

 void main()
 {
     //初始化数据库
     User user;
     Department department;

     //ConcreteFactory1
     AbstractFactory* factory = NULL;
     //factory = new SqlFactory;
     factory = new AccessFactory;
     //ProductA1
     AbstractProductA* iu = NULL;
     iu = factory->createProductA();
     iu->Insert(user);
     iu->GetUser();

     //ProductB1
     AbstractProductB* id = NULL;
     id = factory->createProductB();
     id->Insert(department);
     id->GetDepartment();

     if (factory != NULL)
     {
         delete factory;
         factory = NULL;
     }
     if (iu != NULL)
     {
         delete iu;
         iu = NULL;
     }
     if (id != NULL)
     {
         delete id;
         id = NULL;
     }

     system("pause");

 }

https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/abstract_factory.html

https://blog.csdn.net/xiqingnian/article/details/41181995