工厂模式(Factory Pattern)之简单工厂-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_24345071/article/details/118640541

本文介绍了简单工厂模式在创建怪物类中的应用，通过工厂类隔离了创建对象的代码，实现了代码解耦。简单工厂模式在增加新怪物类型时可能需要修改原有代码，违反了开闭原则，但其易读性良好。文中对比了不使用简单工厂模式的直接实例化方式，并提供了使用简单工厂模式的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

工厂模式(Factory Pattern)之简单工厂

简单工厂模式(Simple Factory)

用途

工厂模式：通过把创建对象的代码包装起来，做到创建对象的代码与具体的业务逻辑代码相隔离的目的。

简单工厂模式：

定义一个工厂类(MonsterFactory)，该类的成员函数(createMonster)可以根据不同参数创建并返回不同的类对象，被创建的对象所属的类（M_Undead，M_Element，M_Mechanic）一般都具有相同的父类（Monster），

调用者（这里指main函数）无需关心创建对象的细节。简单工厂方法模式：实现了创建怪物类代码（createMonster），与具体怪物类（M_Undead，M_Element，M_Mechanic）解耦合的效果。

分类

工厂模式在设计模式中属于创建型模式

具体例子

策划：创建亡灵类怪物，元素类怪物，机械类怪物：都有生命值，魔法值，攻击力三个属性。

实现思路

Monster作为父类，M_Undead（亡灵类），M_Element（元素类怪物），M_Mechanic（机械类怪物）。

使用new +具体类名来创建对象是一种依赖具体类型的紧耦合关系。

简单工厂模式的实现思路：使用工厂类可以实现创建怪物的代码与各个具体怪物类对象要实现的逻辑代码隔离。

利弊

封装变化：把依赖范围尽可能缩小，把容易变化的代码段限制在一个小范围内，就可以在很大程度上提高代码的可维护性和可扩展性。
通过增加新的if else分支来达到支持新怪物增加的目的——违背了面向对象程序设计的原则：开闭原则（Open Close Principle :OCP);

开闭原则：说的是代码扩展性问题——对扩展开放，对修改关闭（封闭）；

开闭原则详细的解释：当增加新功能，不应该通过修改已经存在的代码来进行，而是应该通过扩展代码(比如增加新类，增加新成员函数）来进行。如果if,else分支不多（没有数十上百个），则适当违反开闭原则，是完全可以接受的。大家要在代码的可读性和可扩展性之间做出权衡。

不使用简单工厂模式的代码实现

#include <iostream>

namespace don_not_use_simple_factory {
class Monster {
public:
    Monster(int life, int magic, int attack) : m_life(life), m_magic(magic), m_attack(attack) {}
    virtual ~Monster() {}

protected:
    int m_life;
    int m_magic;
    int m_attack;
};

class M_Undead : public Monster{
public:
    M_Undead(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个亡灵类怪物" << std::endl;
    }

};


class M_Element : public Monster{
public:
    M_Element(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个元素类怪物" << std::endl;
    }

};

class M_Mechanic : public Monster{
public:
    M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个机械类怪物" << std::endl;
    }

};


}; // end of namespace namespace don_not_use_simple_factory


int main() {

    don_not_use_simple_factory::Monster* p_undead = new don_not_use_simple_factory::M_Undead(300, 50, 80);
    don_not_use_simple_factory::Monster* p_element = new don_not_use_simple_factory::M_Element(200, 80, 100);
    don_not_use_simple_factory::Monster* p_mechanic = new don_not_use_simple_factory::M_Mechanic(400, 0, 110);

    delete p_undead;
    delete p_element;
    delete p_mechanic;

    return 0;
}

使用简单工厂模式的实现

#include <iostream>
#include <string>

namespace don_not_use_simple_factory {
class Monster {
public:
    Monster(int life, int magic, int attack) : m_life(life), m_magic(magic), m_attack(attack) {}
    virtual ~Monster() {}

protected:
    int m_life;
    int m_magic;
    int m_attack;
};

class M_Undead : public Monster{
public:
    M_Undead(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个亡灵类怪物" << std::endl;
    }

};


class M_Element : public Monster{
public:
    M_Element(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个元素类怪物" << std::endl;
    }

};

class M_Mechanic : public Monster{
public:
    M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个机械类怪物" << std::endl;
    }

};


}; // end of namespace namespace don_not_use_simple_factory


namespace simple_factory {
class Monster {
public:
    Monster(int life, int magic, int attack) : m_life(life), m_magic(magic), m_attack(attack) {}
    virtual ~Monster() {}

protected:
    int m_life;
    int m_magic;
    int m_attack;
};


class M_Undead : public Monster{
public:
    M_Undead(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个亡灵类怪物" << std::endl;
    }

};


class M_Element : public Monster{
public:
    M_Element(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个元素类怪物" << std::endl;
    }

};

class M_Mechanic : public Monster{
public:
    M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack) {
        std::cout << "创建一个机械类怪物" << std::endl;
    }

};



class MonsterFactory {
public:
    static Monster* createMonster(std::string monster_type) {
        Monster * pobj = nullptr;

        if (monster_type == "uud") {
            pobj = new M_Undead(300, 50, 80);
        } else if (monster_type == "ele") {
            pobj = new M_Element(200, 80, 100);
        } else if (monster_type == "mec") {
            pobj = new M_Mechanic(400, 0, 110);
        }

        return pobj;
    };
    
};


}; // end of namespace simple_fatory


int main() {

    don_not_use_simple_factory::Monster* p_undead = new don_not_use_simple_factory::M_Undead(300, 50, 80);
    don_not_use_simple_factory::Monster* p_element = new don_not_use_simple_factory::M_Element(200, 80, 100);
    don_not_use_simple_factory::Monster* p_mechanic = new don_not_use_simple_factory::M_Mechanic(400, 0, 110);

    delete p_undead;
    delete p_element;
    delete p_mechanic;

    std::cout << "-------------use simple factory----------------" << std::endl;
    simple_factory::Monster* p_und = simple_factory::MonsterFactory::createMonster("uud");
    simple_factory::Monster* p_ele = simple_factory::MonsterFactory::createMonster("ele");
    simple_factory::Monster* p_mec = simple_factory::MonsterFactory::createMonster("mec");

    delete p_und;
    delete p_ele;
    delete p_mec;

    return 0;
}