设计模式之简单工厂，工厂方法和抽象工厂_技术学院_宜昌市隼壹珍商贸有限公司

您好，欢迎访问宜昌市隼壹珍商贸有限公司

400 890 5375
当前位置： 主页 > 新闻动态 > 技术学院

设计模式之简单工厂，工厂方法和抽象工厂

发布时间：2025-07-22  |  点击率：

在面向对象编程中，通常通过继承和虚函数来提供抽象能力，多态性使得程序在运行时，调用者只需处理父类类型，而无需关注具体的子类类型。例如，在一个游戏中，活动对象为动物，如老虎和猫，它们会对主角进行攻击。实现可能如下所示：

代码如下：

class Animal {
public:
    virtual void Attack() = 0;
};

class Tiger : public Animal {
public:
virtual void Attack() {
std::cout << "Tiger Attack!" << std::endl;
}
};
class Cat : public Animal {
public:
virtual void Attack() {
std::cout << "Cat Attack!" << std::endl;
}
};

如果外部有一个方法，不需要关心具体的对象类型，只需使用基类Animal的指针来操作对象，通过多态机制可以实现对具体对象类型的方法调用：

void Attack(Animal pAnimal) {
pAnimal->Attack();
}

调用方式如下（忽略内存释放问题）：

Animal pAnimal = new Tiger;
Attack(pAnimal);
pAnimal = new Cat;
Attack(pAnimal);

输出结果为：

Tiger Attack!
Cat Attack!

上述多态示例表明，在程序实现时，只需操作Animal类并了解其方法即可操作继承自Animal的对象。也就是说，继承自Animal的Cat和Tiger不需要暴露给使用者，可以隐藏Cat和Tiger的创建过程，不需要被调用者所关心。此时，可以通过模块化和工厂设计模式来实现。

例如，将Animal, Cat, Tiger的实现放入一个动态链接库模块中，并且只向调用者暴露Animal的头文件。而工厂方法设计模式，可以使用一个工厂方法创建具体的对象，返回时只返回基类Animal的指针。本文将从简单工厂开始讨论，然后介绍工厂方法和抽象工厂。

简单工厂是大家最常见的一种实现方法，如下所示：

代码如下：

class AnimalFactory {
public:
enum class AnimalType {
TIGER,
CAT
};
static Animal* CreateAnimal(const AnimalType type) {
    if (AnimalType::TIGER == type) {
        return new Tiger;
    }
    else if (AnimalType::CAT == type) {
        return new Cat;
    }
    return nullptr;
}
};


调用方式如下：
Animal pAnimal = AnimalFactory::CreateAnimal(AnimalFactory::AnimalType::TIGER);
Attack(pAnimal);
pAnimal = AnimalFactory::CreateAnimal(AnimalFactory::AnimalType::CAT);
Attack(pAnimal);
然而，这种方式违背了软件开发的开闭原则（Open-Closed Principle, OCP）。如果需要添加一个名为Dog的对象，则需要在CreateAnimal方法中修改分支判断逻辑。简单来说，这种扩展方式破坏了原有逻辑，扩展可能会影响软件的稳定性。


有些人可能不喜欢这种代码方式，但也有人认为这种书写方式比较简单。从个人工程实践经验来看，软件开发设计原则具有很好的指导意义，但并不是所有代码都必须完全符合这些原则。个人的理解如下：


在工程实践中，有时为了让代码完全遵循软件开发设计原则，反而会带来负担，例如过度设计问题。一方面，有些代码模块可能几年都不会被修改扩展；另一方面，当逻辑实现比较简单时，过度设计也会使代码维护者阅读代码更加费劲。毕竟大多数人只是普通的程序员。往往可扩展的代码编写时间更长，但程序员头上的压力还有软件开发时间。对于一般的程序员来说，在规定时间内高质量完成需求是首要任务，此时可能不会完全考虑软件开发设计原则。如果要符合开闭原则，可以实现工厂方法模式，让我们一起来看看。


工厂方法的主要特点是通过继承一个AnimalFactory来实现具体的工厂，例如CatFactory主要负责生产Cat，而TigerFactory主要负责生产Tiger，其类图如下：




代码如下：
class AnimalFactory {
public:
virtual Animal CreateAnimal() = 0;
};
class CatFactory : public AnimalFactory {
public:
virtual Animal* CreateAnimal() {
return new Cat;
}
};
class TigerFactory : public AnimalFactory {
public:
virtual Animal CreateAnimal() {
return new Tiger;
}
};
调用方式如下：
AnimalFactory pFactory = new TigerFactory;
Animal* pAnimal = pFactory->CreateAnimal();
Attack(pAnimal);
pFactory = new CatFactory;
pAnimal = pFactory->CreateAnimal();
Attack(pAnimal);
可以发现，工厂方法模式如果需要扩展一个新的动物类型，也可以对应扩展一个新的工厂，例如增加一个新的DogFactory继承AnimalFactory来生产Dog，从而符合开闭原则，更加安全地进行扩展。然而，这种方式也可以看出，每增加一个新的动物类型就需要新增一个Factory。个人对这种模式的理解如下：


当动物类型的创建过程并不繁琐时，采用这种方式相较于简单工厂而言会更加繁琐；但当初始化过程较多时，使用工厂方法模式扩展会显得更加清晰。这种设计模式的本身实现是取消了条件判断的逻辑，但实际上是将这个条件判断任务交给了使用者去判断选择哪个工厂。


对于新手来说，可能不太容易理解抽象工厂模式，容易将其与工厂方法模式混淆。工厂方法模式中的每个工厂生产一个动物角色，而在抽象工厂中生产一类动物角色的抽象。一个动物角色比较好理解，就是我们上面的CatFactory生产Cat角色，而TigerFactory生产Tiger角色。一类动物角色，我们可以理解为在游戏中，这些动物角色的攻击性分为普通模式和困难模式。


首先，我们将Tiger分为SimpleModeTiger和HardModeTiger；Cat分为SimpleModeCat和HardModeCat。然后，抽象工厂提供CreateAnimal接口，继承的SimpleModeFactory可以生产简单模式的Cat角色和Tiger角色，继承的HardModeFactory可以生产困难模式的Cat角色和Tiger角色。




实现的代码如下所示：
#include 
class Animal {
public:
virtual void Attack() = 0;
};
class AbstractTiger : public Animal {
public:
virtual void Attack() = 0;
};
class SimpleModeTiger : public AbstractTiger {
public:
virtual void Attack() {
std::cout << "SimpleModeTiger Attack!" << std::endl;
}
};
class HardModeTiger : public AbstractTiger {
public:
virtual void Attack() {
std::cout << "HardModeTiger Attack!" << std::endl;
}
};
class AbstractCat : public Animal {
public:
virtual void Attack() = 0;
};
class SimpleModeCat : public AbstractCat {
public:
virtual void Attack() {
std::cout << "SimpleModeCat Attack!" << std::endl;
}
};
class HardModeCat : public AbstractCat {
public:
virtual void Attack() {
std::cout << "HardModeCat Attack!" << std::endl;
}
};
class AbstractAnimalFactory {
public:
virtual Animal* CreateAnimal(AnimalType type) = 0;
};
class SimpleModeAnimalFactory : public AbstractAnimalFactory {
public:
virtual Animal* CreateAnimal(AnimalType type) {
if (type == AnimalType::TIGER) {
return new SimpleModeTiger;
}
else if (type == AnimalType::CAT) {
return new SimpleModeCat;
}
return nullptr;
}
};
class HardModeAnimalFactory : public AbstractAnimalFactory {
public:
virtual Animal* CreateAnimal(AnimalType type) {
if (type == AnimalType::TIGER) {
return new HardModeTiger;
}
else if (type == AnimalType::CAT) {
return new HardModeCat;
}
return nullptr;
}
};
int main() {
// 简单模式
AbstractAnimalFactory pFactory = new SimpleModeAnimalFactory;
Animal pAnimal = pFactory->CreateAnimal(AnimalType::TIGER);
Attack(pAnimal);
pAnimal = pFactory->CreateAnimal(AnimalType::CAT);
Attack(pAnimal);
// 困难模式
pFactory = new HardModeAnimalFactory;
pAnimal = pFactory-youjiankuohaophpcnCreateAnimal(AnimalType::TIGER);
Attack(pAnimal);
pAnimal = pFactory-youjiankuohaophpcnCreateAnimal(AnimalType::CAT);
Attack(pAnimal);
}


为了让结构简单，便于读者理解抽象工厂模式以及与工厂方法模式的区别，上述SimpleModeFactory和HardModeFactory使用的是简单工厂的形式实现的。如果需要符合开闭原则，可以再对SimpleModeFactory和HardModeFactory进行工厂方法的实现。可以想象，如果抽象工厂再加上工厂方法，这个类的结构会变得非常庞大，而且这还仅仅是两个游戏角色的描述。因此，笔者认为在进行工程实践时，尽量避免过度设计，有时反而不利于代码阅读，修改也未必简单。需要权衡好工程和理论的平衡点。


参考：


    

  • 对象工厂和抽象工厂
    • 

  • 秦小波的文章：Does the Factory Pattern violate the Open/Closed Principle?：https://www./link/217cf4dff7b00f89daa441104acbac88

    •

全国统一服务电话

400 890 5375

电子邮箱：879577@qq.com

公司地址：宜昌市西陵区黄河路5号三峡明珠10栋1051室

咨询微信

©  宜昌市隼壹珍商贸有限公司 版权所有   鄂ICP备2024065376号   
北京轩极商贸有限公司 北京轩极商贸有限公司 北京轩极商贸有限公司
宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司 宜昌市隼壹珍商贸有限公司

TEL：13680874598