工厂模式（Factory Pattern） C++

已于 2023-08-11 11:05:04 修改
阅读量753 收藏 2
点赞数 3
分类专栏： 设计模式 文章标签： c++ 工厂模式 设计模式
于 2023-05-30 14:10:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoyaohyl/article/details/130947199
版权

上一节：单例模式（Singleton Pattern） C++

文章目录

0.理论

工厂模式（Factory Pattern） 是一种创建型设计模式，它提供了一种创建对象的接口，但具体的对象创建逻辑被延迟到子类或工厂类中进行实现。这样可以将对象的创建和使用分离，使得系统更加灵活和可扩展。

在工厂模式中，通常会定义一个抽象工厂接口或抽象类，该接口或抽象类声明了一个创建对象的方法，但不具体实现。然后通过具体的工厂类实现这个接口或抽象类，负责创建具体的对象。
工厂模式的核心思想是通过工厂类来封装对象的创建过程，客户端只需要通过工厂类来获取所需的对象，而不需要直接调用对象的构造函数。这样做的好处是，客户端可以通过统一的接口来创建对象，而无需关心具体的创建细节，从而实现了解耦和松耦合。

工厂模式可以分为以下几种类型：

  • 简单工厂模式（Simple Factory Pattern）：由一个工厂类根据传入的参数决定创建哪种产品类的对象。简单工厂模式的核心是一个工厂类，它负责根据外部条件返回合适的对象实例。
  • 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但将具体的对象创建延迟到子类中进行实现。每个子类可以通过实现工厂方法来创建属于自己的对象。
  • 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式可以看作是多个工厂方法模式的组合，它的核心是一个抽象工厂接口，定义了一系列可以创建不同类型对象的方法。

工厂模式的优点包括：

  • 将对象的创建和使用分离，客户端无需关心具体的对象创建过程，只需通过工厂类获取所需的对象。
  • 提供了一种可扩展的方式，当需要新增一种产品时，只需添加相应的具体产品类和对应的工厂类即可，不需要修改现有代码。
  • 提高了代码的可维护性和灵活性，符合面向对象设计原则中的开闭原则。

总之，工厂模式是一种常用的设计模式，可以帮助我们有效地组织和管理对象的创建过程，提高系统的可扩展性和灵活性。

1.实践

1.1 简单工厂模式（Simple Factory Pattern）

假设我们正在开发一个游戏，其中有多个角色可以选择，比如战士（Warrior）、法师（Mage）和射手（Archer）。每个角色都有不同的属性和技能。

首先，我们需要定义一个抽象基类（或接口）作为角色的通用定义：

// 角色基类
class Character {
public:
    virtual void Attack() = 0;
    virtual void Defense() = 0;
    // 其他共有方法和属性
};

接下来，我们创建具体的角色类，实现抽象基类中的方法：

// 战士类
class Warrior : public Character {
public:
    void Attack() override {
        cout << "战士发起了一次攻击！" << endl;
        // 具体的攻击逻辑
    }

    void Defense() override {
        cout << "战士进行了一次防御！" << endl;
        // 具体的防御逻辑
    }
};

// 法师类
class Mage : public Character {
public:
    void Attack() override {
        cout << "法师施放了一次法术攻击！" << endl;
        // 具体的攻击逻辑
    }

    void Defense() override {
        cout << "法师施放了一次防御技能！" << endl;
        // 具体的防御逻辑
    }
};

// 射手类
class Archer : public Character {
public:
    void Attack() override {
        cout << "射手放出了一支箭！" << endl;
        // 具体的攻击逻辑
    }

    void Defense() override {
        cout << "射手使用了闪避技能！" << endl;
        // 具体的防御逻辑
    }
};

接下来，我们定义一个简单工厂类，负责根据输入的角色类型创建对应的角色对象：

// 角色工厂类
class CharacterFactory {
public:
    static Character* CreateCharacter(string characterType) {
        if (characterType == "Warrior")
            return new Warrior();
        else if (characterType == "Mage")
            return new Mage();
        else if (characterType == "Archer")
            return new Archer();
        else
            return nullptr;
    }
};

最后，我们可以在游戏中使用简单工厂模式来创建具体的角色对象：

int main() {
    Character* warrior = CharacterFactory::CreateCharacter("Warrior");
    warrior->Attack();
    warrior->Defense();

    Character* mage = CharacterFactory::CreateCharacter("Mage");
    mage->Attack();
    mage->Defense();

    Character* archer = CharacterFactory::CreateCharacter("Archer");
    archer->Attack();
    archer->Defense();

    delete warrior;
    delete mage;
    delete archer;

    return 0;
}

输出结果可能如下所示：

战士发起了一次攻击！
战士进行了一次防御！
法师施放了一次法术攻击！
法师施放了一次防御技能！
射手放出了一支箭！
射手使用了闪避技能！

通过角色工厂类的CreateCharacter方法来创建不同类型的角色对象，而不需要直接调用具体角色类的构造函数。这样，客户端只需提供角色类型，而不需要关心具体的创建过程，实现了角色对象的创建与使用的解耦。

当然一个游戏得有关卡吧，下面使用 工厂方法模式（Factory Method Pattern）来创建关卡

1.2 工厂方法模式（Factory Method Pattern）

假设我们正在开发一个游戏，其中有多个关卡（Level）需要玩家进行挑战，每个关卡都有不同的怪物（Monster）。
首先，我们定义一个抽象基类（或接口）作为怪物的通用定义：

// 怪物基类
class Monster {
public:
    virtual void Attack() = 0;
    virtual void Defend() = 0;
    // 其他共有方法和属性
};

然后，我们创建具体的怪物类，实现抽象基类中的方法：

// 僵尸类
class Zombie : public Monster {
public:
    void Attack() override {
        cout << "僵尸发起了一次攻击！" << endl;
        // 具体的攻击逻辑
    }

    void Defend() override {
        cout << "僵尸进行了一次防御！" << endl;
        // 具体的防御逻辑
    }
};

// 骷髅类
class Skeleton : public Monster {
public:
    void Attack() override {
        cout << "骷髅发起了一次攻击！" << endl;
        // 具体的攻击逻辑
    }

    void Defend() override {
        cout << "骷髅进行了一次防御！" << endl;
        // 具体的防御逻辑
    }
};

接下来，我们定义一个抽象的关卡基类（或接口），其中包含一个工厂方法用于创建怪物对象：

// 关卡基类
class Level {
public:
    virtual Monster* CreateMonster() = 0;
    // 其他共有方法和属性
};

然后，我们创建具体的关卡类，继承关卡基类，并实现工厂方法来创建对应的怪物对象：

// 第一关卡
class Level1 : public Level {
public:
    Monster* CreateMonster() override {
        return new Zombie();
    }
};

// 第二关卡
class Level2 : public Level {
public:
    Monster* CreateMonster() override {
        return new Skeleton();
    }
};

最后，我们可以在游戏中使用工厂方法模式来创建具体的怪物对象：

int main() {
    Level* level1 = new Level1();
    Monster* monster1 = level1->CreateMonster();
    monster1->Attack();
    monster1->Defend();

    Level* level2 = new Level2();
    Monster* monster2 = level2->CreateMonster();
    monster2->Attack();
    monster2->Defend();

    delete level1;
    delete monster1;
    delete level2;
    delete monster2;

    return 0;
}

需调用关卡类的工厂方法，而不需要关心具体怪物对象的创建过程，实现了关卡对象和怪物对象的解耦。

输出结果可能如下所示：

僵尸发起了一次攻击！
僵尸进行了一次防御！
骷髅发起了一次攻击！
骷髅进行了一次防御！

以上示例展示了在游戏开发中使用工厂方法模式创建不同关卡的怪物对象。通过工厂方法模式，我们可以方便地新增其他关卡和对应的怪物类型，只需创建对应的关卡类并实现工厂方法，而不需要修改现有的怪物类和客户端代码，从而实现了代码的可扩展性和灵活性。
当然，如果你的游戏里有种族分类，每个种族里的建筑以及生活风格和习惯肯定是不一样的。下面就使用工厂方法模式（Factory Method Pattern）来实现不同的种族。

1.3 抽象工厂模式（Abstract Factory Pattern）

假设我们正在开发一个游戏，其中有不同的种族（Race），每个种族都有不同类型的兵种（Unit）和建筑（Building）。

首先，我们定义抽象基类（或接口）用于表示兵种和建筑：

// 兵种基类
class Unit {
public:
    virtual void Attack() = 0;
    virtual void Move() = 0;
    // 其他共有方法和属性
};

// 建筑基类
class Building {
public:
    virtual void ProduceUnit() = 0;
    virtual void Upgrade() = 0;
    // 其他共有方法和属性
};

接下来，我们创建具体的兵种和建筑类，实现抽象基类中的方法：

// 人族兵种类
class HumanUnit : public Unit {
public:
    void Attack() override {
        cout << "人族兵种发起了一次攻击！" << endl;
        // 具体的攻击逻辑
    }

    void Move() override {
        cout << "人族兵种进行了一次移动！" << endl;
        // 具体的移动逻辑
    }
};

// 人族建筑类
class HumanBuilding : public Building {
public:
    void ProduceUnit() override {
        cout << "人族建筑开始生产兵种！" << endl;
        // 具体的生产兵种逻辑
    }

    void Upgrade() override {
        cout << "人族建筑进行了一次升级！" << endl;
        // 具体的升级逻辑
    }
};

// 兽族兵种类
class OrcUnit : public Unit {
public:
    void Attack() override {
        cout << "兽族兵种发起了一次攻击！" << endl;
        // 具体的攻击逻辑
    }

    void Move() override {
        cout << "兽族兵种进行了一次移动！" << endl;
        // 具体的移动逻辑
    }
};

// 兽族建筑类
class OrcBuilding : public Building {
public:
    void ProduceUnit() override {
        cout << "兽族建筑开始生产兵种！" << endl;
        // 具体的生产兵种逻辑
    }

    void Upgrade() override {
        cout << "兽族建筑进行了一次升级！" << endl;
        // 具体的升级逻辑
    }
};

接下来，我们定义一个抽象工厂基类（或接口），用于创建兵种和建筑：

// 抽象工厂基类
class AbstractFactory {
public:
    virtual Unit* CreateUnit() = 0;
    virtual Building* CreateBuilding() = 0;
};

然后，我们创建具体的工厂类，继承抽象工厂基类，并实现创建兵种和建筑的方法：

// 人族工厂
class HumanFactory : public AbstractFactory {
public:
    Unit* CreateUnit() override {
        return new HumanUnit();
    }

    Building* CreateBuilding() override {
        return new HumanBuilding();
    }
};
// 兽族工厂类
class OrcFactory : public AbstractFactory {
public:
    Unit* CreateUnit() override {
        return new OrcUnit();
    }

    Building* CreateBuilding() override {
        return new OrcBuilding();
    }
};

最后，我们可以在游戏中使用抽象工厂模式来创建具体的兵种和建筑对象：

int main() {
    AbstractFactory* humanFactory = new HumanFactory();
    Unit* humanUnit = humanFactory->CreateUnit();
    Building* humanBuilding = humanFactory->CreateBuilding();

    humanUnit->Attack();
    humanUnit->Move();

    humanBuilding->ProduceUnit();
    humanBuilding->Upgrade();

    delete humanUnit;
    delete humanBuilding;
    delete humanFactory;

    AbstractFactory* orcFactory = new OrcFactory();
    Unit* orcUnit = orcFactory->CreateUnit();
    Building* orcBuilding = orcFactory->CreateBuilding();

    orcUnit->Attack();
    orcUnit->Move();

    orcBuilding->ProduceUnit();
    orcBuilding->Upgrade();

    delete orcUnit;
    delete orcBuilding;
    delete orcFactory;

    return 0;
}

通过使用抽象工厂模式，我们可以通过具体的工厂类来创建属于特定种族的兵种和建筑对象，而不需要直接调用具体类的构造函数。客户端只需要使用抽象工厂对象，而不需要关心具体对象的创建过程，从而实现了客户端代码与具体类的解耦。

输出结果可能如下所示：

人族兵种发起了一次攻击！
人族兵种进行了一次移动！
人族建筑开始生产兵种！
人族建筑进行了一次升级！
兽族兵种发起了一次攻击！
兽族兵种进行了一次移动！
兽族建筑开始生产兵种！
兽族建筑进行了一次升级！

以上示例展示了在游戏开发中使用抽象工厂模式创建不同种族的兵种和建筑对象。通过抽象工厂模式，我们可以方便地新增其他种族和对应的兵种、建筑类型，只需创建对应的工厂类并实现工厂方法，而不需要修改现有的兵种、建筑类和客户端代码，从而实现了代码的可扩展性和灵活性。

下一节：模板方法模式（Template Method Pattern） C++

yaoyaohyl
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式实战学习笔记（三）：工厂（简单工厂、工厂模式和抽象工厂）、建造者模式
weixin_44003309的博客
08-16 262
（九）工厂模式（简单工厂、工厂模式和抽象工厂） 创建战士工厂： 创建ICharacterFactory工厂接口，和继承其的子类 SoldierFactory 和 EnemyFactory 在IWeapon中 声明枚举类 WeaponType 武器类型 在ICharacterAttri中对其构造函数进行改写，对其属性进行初始化（后续不做改变） using System.Colle...
C++实现工厂方法模式Factory Method Pattern
CSDNer_2015的博客
09-29 280
工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
C++ 工厂模式（Factory Pattern）
你好，旅行者
01-22 390
//FactoryPattern.h #pragma once #include //base one factory pattern. enum PRODUCT { ONE, TWO, THREE, FOUR }; class SimpleAbstractProduct { public: virtual void Print() = 0; }; class SimpleOneAbstr
C++设计模式之Factory(工厂)模式
云彩挂上的二叉树
12-01 2164
工厂模式一般是学习设计模式的第一课,它本身也是创建型模式中较为常用的一种模式. 工厂模式希望解决的是"如何高效而方便的创建当前需要的对象"的问题.当一个对象对外提供的接口稳定,而这类对象的具体实现容易发生变化时,我们可以考虑使用工厂来封装对象的实现变化,并提供统一的对象创建方法. 工厂模式可以分为三种不同的模式,分别对应不同情况下的解决方案. 1.简单工厂模式
Head First 设计模式 （四） 工厂模式（factory pattern） C++实现
04-03
1. **抽象工厂（Abstract Factory）**：这是工厂模式的核心接口，定义了创建产品对象的公共接口。在C++中，通常用抽象类或者纯虚函数接口来表示。 2. **具体工厂（Concrete Factory）**：实现了抽象工厂接口，负责...
c++设计模式-抽象工厂方法
06-04
在C++中，抽象工厂模式通常包含以下角色： 1. **抽象工厂（Abstract Factory）**：定义一个创建对象的接口，但不指定具体的实现。在C++中，这通常是一个纯虚类，声明了一系列用于创建对象的纯虚函数。 2. **具体工厂...
C++factory pattern
12-05
C++工厂模式是一种设计模式，属于创建型模式，它提供了一种封装对象创建的方式，使得客户端无需知道具体的创建逻辑，而是通过一个公共的接口来获取所需的对象。在给定的例子中，我们可以通过以下文件了解其具体实现...
C++工厂模式源码及文档说明
10-18
首先，简单工厂模式（Simple Factory Pattern）是工厂模式的最基础形式。它提供一个静态方法来创建对象，该方法根据输入参数决定创建哪个类的实例。这种模式适用于当产品种类不多，且不需频繁添加新产品的情况。在...
DesignPattern_设计模式c++_
10-04
2. **工厂模式（Factory）**：提供一个接口，用于创建一组相关或相互依赖的对象，而无需指定它们的具体类。在C++中，可以使用抽象工厂类或者模板来实现。 3. **抽象工厂模式（Abstract Factory）**：为一个家族相关...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1065
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1101
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 400
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 299
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 239
C++笔记3：基类指针delete子类对象的内存泄漏问题
Delphi5实现鱼C屏幕保护程序
weixin_52116519的博客
07-24 173
使用Form1的events的oncreate事件，双击命名为FormCreate。即上面的“- □ ×”不显示。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 1万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 1703
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
【C++初阶】string类
最新发布
2301_78022459的博客
07-24 466
【C++初阶】string类
Abstract Factory Pattern设计模式及C++代码
02-14
Abstract Factory Pattern是一种设计模式，它是创建对象的工厂模式的变体，允许对象在运行时被替换。 Abstract Factory模式提供了一种方法，可以创建一组相关或相互依赖的对象，而不需要明确指定其具体类。 下面是一个C语言的代码示例，该代码实现了一个抽象工厂模式，该模式创建一组车辆： ```c #include <stdio.h> typedef struct IVehicle IVehicle; struct IVehicle { void (*Drive)(IVehicle *); }; typedef struct Car Car; struct Car { IVehicle base; int wheelCount; }; void Car_Drive(IVehicle *vehicle) { Car *car = (Car *)vehicle; printf("Driving a car with %d wheels\n", car->wheelCount); } typedef struct Bike Bike; struct Bike { IVehicle base; int pedalCount; }; void Bike_Drive(IVehicle *vehicle) { Bike *bike = (Bike *)vehicle; printf("Riding a bike with %d pedals\n", bike->pedalCount); } typedef struct IVehicleFactory IVehicleFactory; struct IVehicleFactory { IVehicle *(*CreateVehicle)(IVehicleFactory *); }; typedef struct CarFactory CarFactory; struct CarFactory { IVehicleFactory base; }; IVehicle *CarFactory_CreateVehicle(IVehicleFactory *factory) { Car *car = (Car *)malloc(sizeof(Car)); car->base.Drive = &Car_Drive; car->wheelCount = 4; return (IVehicle *)car; } typedef struct BikeFactory BikeFactory; struct BikeFactory { IVehicleFactory base; }; IVehicle *BikeFactory_CreateVehicle(IVehicleFactory *factory) { Bike *bike = (Bike *)malloc(sizeof(Bike)); bike->base.Drive = &Bike_Drive; bike->pedalCount = 2; return (IVehicle *)bike; } int main(int argc, char *argv[]) { CarFactory carFactory = { { &CarFactory_CreateVehicle } }; IVehicle *vehicle = carFactory.base.CreateVehicle((IVehicleFactory *)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值