C++ 设计模式之抽象工厂模式

【声明】本编码题目来源于【题目页面 (kamacoder.com)】

---

【提示：如果不想看文字介绍，可以直接跳转到C++编码部分】

【简介】什么是抽象工厂模式

????????抽象??模式也是?种创建型设计模式，提供了?个创建?系列相关或相互依赖对象的接?，??需指定它们具体的类。
????????在???法模式中，每个具体??只负责创建单?的产品。但是如果有多类产品呢，?如说“?机”，?个品牌的?机有?端机、中低端机之分，这些具体的产品都需要建??个单独的??类，但是它们都是相互关联的，都共同属于同?个品牌，这就可以使?到【抽象??模式】。

????????抽象??模式可以确保?系列相关的产品被?起创建，这些产品能够相互配合使?，再举个例?，有?些家具，?如沙发、茶?、椅?，都具有古典?格的和现代?格的，抽象??模式可以将?产现代?格的家具放在?个??类中，将?产古典?格的家具放在另?个??类中，这样每个??类就可以?产?系列的家具。

---

【基本结构】

????????抽象??模式包含多个抽象产品接?，多个具体产品类，?个抽象??接?和多个具体??，每个具体??负责创建?组相关的产品。

• 抽象产品接?AbstractProduct : 定义产品的接?，可以定义多个抽象产品接?，?如说沙发、椅?、茶?都是抽象产品。
• 具体产品类ConcreteProduct : 实现抽象产品接?，产品的具体实现，古典?格和沙发和现代?格的沙发都是具体产品。
• 抽象??接?AbstractFactory : 声明?组?于创建产品的?法，每个?法对应?个产品。
• 具体??类ConcreteFactory ： 实现抽象??接?，负责创建?组具体产品的对象，在本例中，?产古典?格的??和?产现代?格的??都是具体实例。

????????在上?的图示中：

????????AbstractProductA/B/C 就是抽象产品，

????????ConcreteProductA2/A2/B1/B2/C1/C2 就是抽象产品的实现，

????????AbstractFactory 定义了抽象??接?，接??的?法?于创建具体的产品，ConcreteFactory就是具体??类，可以创建?组相关的产品。

---

【实现步骤】

• 定义抽象产品接?（可以有多个），接?中声明产品的公共?法。
• 实现具体产品类，在类中实现抽象产品接?中的?法。
• 定义抽象??接?，声明?组?于创建产品的?法。
• 实现具体??类，分别实现抽象??接?中的?法，每个?法负责创建?组相关的产品。
• 在客户端中使?抽象??和抽象产品，?不直接使?具体产品的类名。

---

【C++编码实例】

1.题目描述

????????小明家新开了两个工厂用来生产家具，一个生产现代风格的沙发和椅子，一个生产古典风格的沙发和椅子，现在工厂收到了一笔订单，请你帮他设计一个系统，描述订单需要生产家具的信息。

2.输入描述

????????输入的第一行是一个整数 N（1 ≤ N ≤ 100），表示订单的数量。?接下来的 N 行，每行输入一个字符串，字符串表示家具的类型。家具类型分为 "modern" 和 "classical" 两种。

3.输出描述

????????对于每笔订单，输出字符串表示该订单需要生产家具的信息。?

modern订单会输出下面两行字符串 ：

????????modern chair?

????????modern sofa

classical订单会输出下面两行字符串 ：

????????classical chair?

????????classical soft

4.编码实现

#include <iostream>
#include <vector>
#include <string>

using namespace std;
// 前置声明
class Sofa;
class Chair;
class Classic;
class ModernSofa;
class ModernChair;
class ClassicSofa;
class ClassicChair;

// 定义抽象产品

// 现代风格类
class Sofa{
public:
    // 声明虚函数时一定要加上空实现  或者声明为纯虚函数
    virtual void PrintSofa() = 0;
};

// 古典风格类
class Chair{
public:    
    // 声明虚函数时一定要加上空实现  或者声明为纯虚函数
    virtual void PrintChair() = 0;
};

// 实现具体产品类

// 现代风格的沙发
class ModernSofa : public Sofa
{
public:    
    void PrintSofa() override
    {
        std::cout << "modern sofa" << endl;
    }
};

// 现代风格的椅子
class ModernChair : public Chair
{
public:    
    void PrintChair() override
    {
        std::cout << "modern chair" << endl;
    }
};

// 古典风格的沙发
class ClassicSofa : public Sofa
{
public:    
    void PrintSofa() override
    {
        std::cout << "classical sofa" << endl;
    }
};


// 古典风格的椅子
class ClassicChair : public Chair
{
public:    
    void PrintChair() override
    {
        std::cout << "classical chair" << endl;
    }
};


// 定义抽象工厂接口 -- 实例化 抽象的产品（风格）
class ProductFactory{
public:    
    // 后续需要重写
    // 声明虚函数时一定要加上空实现  或者声明为纯虚函数
    virtual Sofa* CreateSofa() = 0;
    virtual Chair* CreateChair() = 0;
};


// 实现具体工厂类（以产品的特性分类 而不是具体的产品）

// 现代工厂
class ModernProductFactory : public ProductFactory
{
public: 
    // 生产现代风的沙发
    Sofa* CreateSofa() override
    {
        return (new ModernSofa());
    }
    
    // 生产现代风的椅子
    Chair* CreateChair() override
    {
        return (new ModernChair());
    }
    
};

// 古典工厂
class ClassicProductFactory : public ProductFactory
{
public:    
    // 生产古典风的沙发
    Sofa* CreateSofa() override
    {
        return (new ClassicSofa());
    }
    
    // 生产古典风的椅子
    Chair* CreateChair() override
    {
        return (new ClassicChair());
    }
};

// 工厂产品 管理类

int main()
{
    // 产品工厂的抽象基类  用于后续不同派生类的创建
    ProductFactory *factoryPointer = nullptr;
    
    // 订单数量
    int orderNum = 0;
    // 输入的家具类型
    string furnitureType = "";
    // 已有家具类型
    string modern = "modern";
    string classical = "classical";
    // 输入订单数量
    std::cin >>  orderNum;
    
    for(int i = 0; i < orderNum; i++)
    {
        std::cin >> furnitureType;
        if(furnitureType == modern)
        {
            // 创建 现代 工厂
            factoryPointer = new ModernProductFactory();
            // 创建具体化的 椅子和沙发 对象 同时使用dynamic_cast完成向下类型转换
            ModernSofa *sofa = dynamic_cast<ModernSofa *>(factoryPointer->CreateSofa());
            ModernChair *chair = dynamic_cast<ModernChair *>(factoryPointer->CreateChair());
            // 执行相应操作
            chair->PrintChair();
            sofa->PrintSofa();
            
            // 用完记得析构掉
            delete chair;
            chair = nullptr;
            delete sofa;
            sofa = nullptr;
        }
        else if(furnitureType == classical)
        {
            // 创建古典工厂
            factoryPointer = new ClassicProductFactory();
            // 创建具体化的 椅子和沙发 对象
            ClassicSofa *sofa = dynamic_cast<ClassicSofa *>(factoryPointer->CreateSofa());
            ClassicChair *chair = dynamic_cast<ClassicChair *>(factoryPointer->CreateChair());
            // 执行相应操作
            chair->PrintChair();
            sofa->PrintSofa();
            
            // 用完记得析构掉
            delete chair;
            chair = nullptr;
            delete sofa;
            sofa = nullptr;
        }
        else continue;
        
        // 用完记得析构掉
        delete factoryPointer;
        factoryPointer = nullptr;
    }
    return 0;
}

......

To be continued.

---

【补充】简单??、???法、抽象??的区别

• 简单??模式：?个???法创建所有具体产品
• ???法模式：?个???法创建?个具体产品
• 抽象??模式：?个???法可以创建?类具体产品