《大话设计模式》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) = 0;
    virtual User* GetUser(int id) = 0;
};

//具体产品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) = 0;
    virtual  Department* GetDepartment(int id) = 0;
};


//具体产品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() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

//具体工厂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(1);

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

    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