C++设计模式（十一）—抽象工厂模式

抽象工厂模式

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

本文使用书中数据访问程序的例子，代码使用C++语言描述，代码存在的不足或问题有望各位指出。

抽象工厂模式的数据访问程序

#include <iostream>
using namespace std;
class User
{
public:
    int get_id()
    {
        return _id;
    }
    void set_id(int value)
    {
        _id = value;
    }
    string get_string()
    {
        return _name;
    }
    void set_string(string name)
    {
        _name =name;
    }
private:
    int _id;
    string _name;
};

class IUser
{
public:
    IUser(){}
    virtual ~IUser(){}
    virtual void Insert(User *user)=0;
    virtual User* getUser(int id) =0;
};

class SqlserverUser : public IUser
{
public:
    void Insert(User *user) override
    {
        cout << "在SQL Server中给User表增加一条记录"<< endl;
    }
    User* getUser(int id) override
    {
        cout << "在SQL Server中根据ID得到User表一条记录" <<endl;
        return nullptr;
    }
};

class AccessUser :public IUser
{
public:
    void Insert(User *user) override
    {
        cout << "在Access中给User表增加一条记录" <<endl;
    }
    User* getUser( int id) override
    {
        cout << "在Accss中根据ID得到User表一条记录" <<endl;
        return nullptr;
    }
};


class Department
{
public:
    int get_id()
    {
        return _id;
    }
    void set(int id)
    {
        _id = id;
    }

    string get_name()
    {
        return _deptName;
    }
    void set_name(string name)
    {
        _deptName = name;
    }
private:
    int _id;
    string _deptName;
};
class IDepartment
{
public:
    IDepartment(){}
    virtual ~IDepartment(){}
    virtual void Insert(Department *department)=0;
    virtual Department *getDepartment(int id) =0;


};

class SqlserverDepartment:public IDepartment
{
public:
    void Insert(Department* department)
    {
        cout << "在SQL Server中给Department表增加一条记录" << endl;
    }
    Department* getDepartment(int id)
    {
        cout << "在SQL Server中根据ID得到Department表一条记录" <<endl;
        return nullptr;
    }
};


class AccessDepartment:public IDepartment
{
public:
    void Insert(Department *department)
    {
        cout << "在Access中给Department表增加一条记录"<<endl;
    }
    Department *getDepartment(int id)
    {
        cout <<"在Access中根据ID得到Department表一条记录"<<endl;
        return nullptr;
    }
};



class IFactory
{
public:
    IFactory(){}
    virtual ~IFactory(){}
    virtual IUser* createUser() =0;
    virtual  IDepartment* createDepartment() =0;
};

class SqlServerFactory : public IFactory
{
public:
    IUser* createUser() override
    {
        return new SqlserverUser();
    }
    IDepartment* createDepartment() override
    {
        return new SqlserverDepartment();
    }
};

class AccessFactory : public IFactory
{
public:
    IUser* createUser() override
    {
        return new AccessUser();
    }
    IDepartment* createDepartment() override
    {
        return new AccessDepartment();
    }
};


int main()
{
    User *user = new User();
    Department *dept = new Department();
    IFactory *factory = new AccessFactory();
    IUser *iu = factory->createUser();
    iu->Insert(user);
    iu->getUser(1);

    IDepartment *id = factory->createDepartment();
    id->Insert(dept);
    id->getDepartment(1);
    delete user;
    delete dept;
    delete factory;
    return 0;
}

抽象工程模式的优点与缺点

优点

1、便于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。

2、它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端。

缺点

如果需求来自增加功能，那么我们至少增加三个类，同时客户端程序类显然不会只有一个，这样需要大量的改动。