【C++】—— 工厂模式详解

（一）工厂模式的特点

1、优势

• ⼯⼚模式是⼀种创建型设计模式， 它提供了⼀种创建对象的最佳⽅式；
• 在⼯⼚模式中，我们创建对象时不会对上层暴露创建逻辑，⽽是通过使⽤⼀个共同结构来指向新创建的对象，以此实现创建-使⽤的分离。

2、缺点

尽管工厂模式在许多情况下是一种有用的设计模式，但它也有一些缺点需要考虑：

• 除了原来的产品类和客户端代码外，还需要定义工厂接口、具体工厂类等额外的类。这可能导致系统变得更加复杂，特别是当需要创建多个不同类型的对象时。

但是尽管工厂模式存在上述缺点，但在许多情况下它仍然是一种有用的设计模式。在实际应用中，我们需要权衡使用工厂模式带来的好处和缺点，并根据具体情况进行选择。

（二）工厂模式分类

工厂模式可以分为三种不同的类型：简单工厂模式、工厂方法模式和抽象工厂模式。

1、简单工厂模式

简单⼯⼚模式实现由⼀个⼯⼚对象通过类型决定创建出来指定产品类的实例。

• 假设有个⼯⼚能⽣产出⽔果，当客⼾需要产品的时候明确告知⼯⼚⽣产哪类⽔果，⼯⼚需要接收⽤⼾提供的类别信息，当新增产品的时候，⼯⼚内部去添加新产品的⽣产⽅式

接下来，我们看代码演示：

#include<iostream>
#include <string>
#include <memory>
 
class Fruit{
    public:
        Fruit(){}
        virtual void show() = 0;
};
class Apple : public Fruit{
    public:
        Apple(){}
        virtual void show(){
            std::cout << "我是一个苹果" << std::endl;
        }
};
 
class Banana : public Fruit{
    public:
        Banana(){}
        virtual void show(){
            std::cout << "我是一个香蕉" << std::endl;
        }
};
 
class FruitFactory{
    public:
        static std::shared_ptr<Fruit> create(const std::string &name){
            if(name == "苹果"){
                return std::make_shared<Apple>();
            }
            else if(name == "香蕉"){
                return std::make_shared<Banana>();
            }
            else{
                return std::shared_ptr<Fruit>(); 
            }
        }
};
int main()
{
    std::shared_ptr<Fruit> fruit = FruitFactory::create("苹果");
    fruit->show();
    fruit = FruitFactory::create("香蕉");
    fruit->show();
    return 0;
}

运行结果如下：

2、工厂方法模式

工厂方法模式定义一个创建对象的接口，但将实际的实例化延迟到子类中。每个子类都可以根据需要创建适合自身的对象。

• 假设现在有A、B 两种产品，则开两个⼯⼚，⼯⼚ A 负责⽣产产品 A，⼯⼚ B 负责⽣产产品 B，⽤⼾只知道产品的⼯⼚名，⽽不知道具体的产品信息，⼯⼚不需要再接收客⼾的产品类别，⽽只负责⽣产产品。

接下来，我们还是看代码演示：

#include<iostream>
#include <string>
#include <memory>
 
class Fruit{
    public:
        Fruit(){}
        virtual void show() = 0;
};
class Apple : public Fruit{
    public:
        Apple(){}
        virtual void show(){
            std::cout << "我是一个苹果" << std::endl;
        }
};
class Banana : public Fruit{
    public:
        Banana(){}
        virtual void show(){
            std::cout << "我是一个香蕉" << std::endl;
        }
};
//工厂模式方法
class FruitFactory{
    public:
        virtual std::shared_ptr<Fruit> create() = 0;
};
 
class AppleFactory : public FruitFactory{
    public:
        virtual std::shared_ptr<Fruit> create(){
            return std::make_shared<Apple>();
        }
};
 
class BananaFactory : public FruitFactory{
    public:
        virtual std::shared_ptr<Fruit> create(){
            return std::make_shared<Banana>();
        }
};
 
int main()
{
    std::shared_ptr<FruitFactory> factory(new AppleFactory());
    std::shared_ptr<Fruit> fruit = factory->create();
    fruit->show();
    factory.reset(new BananaFactory());
    fruit = factory->create();
    fruit->show();
    return 0;
}

运行结果如下：

⼯⼚⽅法模式通过引⼊⼯⼚等级结构，解决了简单⼯⼚模式中⼯⼚类职责太重的问题，但由于⼯⼚⽅法模式中的每个⼯⼚只⽣产⼀类产品，可能会导致系统中存在⼤量的⼯⼚类，势必会增加系统的开销。———— 由此就引入了抽象工厂模式。

3、抽象工厂模式

可以考虑将⼀些相关的产品组成⼀个产品族（位于不同产品等级 结构中功能相关联的产品组成的家族），由同⼀个⼯⼚来统⼀⽣产，这就是抽象⼯⼚模式的基本思想。

接下来，我们还是看代码演示：

#include<iostream>
#include <string>
#include <memory>
 
//产品类一：水果
class Fruit{
    public:
        Fruit(){}
        virtual void show() = 0;
};
class Apple : public Fruit{
    public:
        Apple(){}
        virtual void show(){
            std::cout << "我是一个苹果" << std::endl;
        }
};
 
class Banana : public Fruit{
    public:
        Banana(){}
        virtual void show(){
            std::cout << "我是一个香蕉" << std::endl;
        }
};
 
 
//产品类二：动物
class Animal {
    public:
        virtual void voice() = 0;
};
 
class Lamp: public Animal {
    public:
        void voice() override { std::cout << "咩咩咩\n"; }
};
 
class Dog: public Animal {
    public:
        void voice() override { std::cout << "汪汪汪\n"; }
};
 
 
class Factory {
    public:
        virtual std::shared_ptr<Fruit> getFruit(const std::string &name) = 0;
        virtual std::shared_ptr<Animal> getAnimal(const std::string &name) = 0;
};
 
class FruitFactory : public Factory {
    public:
        virtual std::shared_ptr<Animal> getAnimal(const std::string &name) {
            return std::shared_ptr<Animal>();
        }
    virtual std::shared_ptr<Fruit> getFruit(const std::string &name) {
        if (name == "苹果") {
            return std::make_shared<Apple>();
        }else if(name == "⾹蕉") {
            return std::make_shared<Banana>();
        }
        return std::shared_ptr<Fruit>();
    }
};
 
class AnimalFactory : public Factory {
    public:
        virtual std::shared_ptr<Fruit> getFruit(const std::string &name) {
            return std::shared_ptr<Fruit>();
        }
        virtual std::shared_ptr<Animal> getAnimal(const std::string &name) {
            if (name == "⼩⽺") {
                return std::make_shared<Lamp>();
            }else if(name == "⼩狗") {
                return std::make_shared<Dog>();
            }
            return std::shared_ptr<Animal>();
        }
};
 
 
class FactoryProducer {
    public:
        static std::shared_ptr<Factory> getFactory(const std::string &name) {
            if (name == "动物") {
                return std::make_shared<AnimalFactory>();
            }else {
                return std::make_shared<FruitFactory>();
            }   
        }
};
 
 
int main()
{
    std::shared_ptr<Factory> fruit_factory = FactoryProducer::getFactory("⽔果");
    std::shared_ptr<Fruit> fruit = fruit_factory->getFruit("苹果");
    fruit->show();
    fruit = fruit_factory->getFruit("⾹蕉");
    fruit->show();
 
    std::shared_ptr<Factory> animal_factory = FactoryProducer::getFactory("动物");
    std::shared_ptr<Animal> animal = animal_factory->getAnimal("⼩⽺");
    animal->voice();
    animal = animal_factory->getAnimal("⼩狗");
    animal->voice();
 
    return 0;
}

运行结果如下：

（三）总结与回顾