《大話設計模式》讀書筆記之C++實現--chapter15抽象工廠模式

#include <iostream>
using namespace std;

//抽象產品類
class AbstractProduct{
public:
    virtual void ProductFunction() = 0;     //子類可以重寫該函數來實現不同子類的特有功能
    virtual ~AbstractProduct(){}
};

//具體產品類，有實現自己功能的成員函數
class ConcreteProductA:public AbstractProduct{
public:
    void ProductFunction()
    {
        cout << "ConcreteProductA do its function" << endl;
    }
};

class ConcreteProductB:public AbstractProduct{
public:
    void ProductFunction()
    {
        cout << "ConcreteProductB do its function" << endl;
    }
};

//抽象工廠類，可以生產不同的產品
class AbstractFactory{
public:
    virtual AbstractProduct* CreateProduct() = 0;
    virtual ~AbstractFactory(){}
};

class ConcreteFactoryA:public AbstractFactory{
public:
    AbstractProduct* CreateProduct()
    {
        return new ConcreteProductA();
    }
};

class ConcreteFactoryB:public AbstractFactory{
public:
    AbstractProduct* CreateProduct()
    {
        return new ConcreteProductB();
    }
};

int main(int argc,char** argv)
{
    AbstractFactory *factoryA = new ConcreteFactoryA();
    AbstractFactory *factoryB = new ConcreteFactoryB();
    AbstractProduct *productA = factoryA->CreateProduct();
    AbstractProduct *productB = factoryB->CreateProduct();
    productA->ProductFunction();
    productB->ProductFunction();
    return 0;
}

以下是書中具體的一個DB例子

#include <iostream>
using namespace std;

class User{

};

class IUser{
public:
    virtual void Insert(User user) = 0;
    virtual void GetId(User user) = 0;
};

class SqlServerUser:public IUser{
public:
    void Insert(User user)
    {
        cout << "use sqlserver insert into user" << endl;
    }
    void GetId(User user)
    {
        cout << "use sqlserver get user id " << endl;
    }
};

class AccessUser:public IUser{
public:
    void Insert(User user)
    {
        cout << "use AccessUser insert into user" << endl;
    }
    void GetId(User user)
    {
        cout << "use AccessUser get user id " << endl;
    }
};

class IFactory{
public:
    virtual IUser* CreateUser() = 0;
};

class SqlServerFactory:public IFactory{
public:
    IUser* CreateUser()
    {
        return new SqlServerUser();
    }
};

class AcceseFactory:public IFactory{
public:
    IUser* CreateUser()
    {
        return new AccessUser();
    }
};

int main(int argc,char** argv)
{
    User user;
    IFactory* access = new AcceseFactory();
    IUser* accessUser = access->CreateUser();
    accessUser->Insert(user);
    return 0;
}

利用簡單工廠來改進抽象工廠，也就是將選擇工廠轉移到類中決定，而不必通過繼承的各種子類來決定

#include <iostream>
#include <string>
using namespace std;

//抽象產品類
class AbstractProduct{
public:
    virtual void ProductFunction() = 0;     //子類可以重寫該函數來實現不同子類的特有功能
    virtual ~AbstractProduct(){}
};

//具體產品類，有實現自己功能的成員函數
class ConcreteProductA:public AbstractProduct{
public:
    void ProductFunction()
    {
        cout << "ConcreteProductA do its function" << endl;
    }
};

class ConcreteProductB:public AbstractProduct{
public:
    void ProductFunction()
    {
        cout << "ConcreteProductB do its function" << endl;
    }
};

//產品枚舉類，代表不同產品
enum ProductType{
    ConcreteA,
    ConcreteB
};

//抽象工廠類，可以生產不同的產品
class Factory{
public:
    static AbstractProduct* CreateProduct()
    {
        switch (m_ProductType) {
        case ConcreteA:
            return new ConcreteProductA();
            break;
        case ConcreteB:
            return new ConcreteProductB();
            break;
        default:
            return nullptr;
            break;
        }
    }

private:
    static ProductType m_ProductType;
};

//在類外初始化static數據成員並決定生成哪種產品
ProductType Factory::m_ProductType = ConcreteB;


int main(int argc,char** argv)
{
    AbstractProduct *product = Factory::CreateProduct();
    product->ProductFunction();
    return 0;
}