C++ 设计模式——工厂模式

一、简单工厂模式

简单工厂模式:简单工厂模式实现由⼀个工厂对象通过类型决定创建出来指定产品类的实例。假设 有个工厂能生产出⽔果，当客户需要产品的时候明确告知工厂生产哪类⽔果，工厂需要接收用户提 供的类别信息，当新增产品的时候，工厂内部去添加新产品的生产⽅式。

#include <iostream>
#include <string>
#include <memory>

//创建水果类型
class Fruit
{
public:
    virtual void showName() = 0;
};

class Apple : public Fruit
{
public:
    void showName() override 
    {
        std::cout << "我是一个苹果！" << std::endl;
    }
};

class Banana : public Fruit
{
public:
    void showName() override 
    {
        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 //这里是因为我只有两个类型
        {
            return std::make_shared<Banana>();
        }
    }
};

int main()
{
    //用水果工厂产出水果
    std::shared_ptr<Fruit> fruit = FruitFactory::create("苹果");
    fruit->showName();
    fruit = FruitFactory::create("香蕉");
    fruit->showName();
    return 0;
}

这个模式的结构和管理产品对象的⽅式十分简单，但是它的扩展性⾮常差，当我们需要新增产品的时 候，就需要去修改工厂类新增⼀个类型的产品创建逻辑，违背了开闭原则。

二、工厂方法模式

工厂⽅法模式:在简单工厂模式下新增多个工厂，多个产品，每个产品对应⼀个工厂。假设有 A、B两种产品，则开两个工厂，工厂A负责⽣产产品A，工厂B负责⽣产产品B，用户只知道产品 的工厂名，而不知道具体的产品信息，工厂不需要再接收客⼾的产品类别，而只负责生产产品。

#include <iostream>
#include <string>
#include <memory>

//创建水果类型
class Fruit
{
public:
    virtual void showName() = 0;
};

class Apple : public Fruit
{
public:
    void showName() override 
    {
        std::cout << "我是一个苹果！" << std::endl;
    }
};

class Banana : public Fruit
{
public:
    void showName() override 
    {
        std::cout << "我是一个香蕉！" << std::endl;
    }
};

//创建水果工厂
class FruitFactory
{
public:
    virtual std::shared_ptr<Fruit> create() = 0;
};

class AppleFactory : public FruitFactory //苹果工厂
{
public:
    std::shared_ptr<Fruit> create() override 
    {
        std::cout << "苹果工厂产出一个苹果！" << std::endl;
        return std::make_shared<Apple>();
    } 
};

class BananaFactory : public FruitFactory //香蕉工厂
{
public:
    std::shared_ptr<Fruit> create() override 
    {
        std::cout << "苹果工厂产出一个香蕉！" << std::endl;
        return std::make_shared<Banana>();
    } 
};


int main()
{
    std::shared_ptr<FruitFactory> FF(new AppleFactory()); //FF为苹果工厂
    std::shared_ptr<Fruit> af = FF->create();
    af->showName();

    FF.reset(new BananaFactory()); //FF更改为香蕉工厂
    std::shared_ptr<Fruit> bf = FF->create();
    bf->showName();

    return 0;
}

工厂⽅法模式每次增加一个产品时，都需要增加⼀个具体产品类和工厂类，这会使得系统中类的个数成倍增加，在一定程度上增加了系统的耦合度。

简单理解就是一个工厂对应一种产品，有一个基类工厂和一个基类产品，基类工厂是工厂类的模板，基类产品是产品类的模板。

三、抽象工厂

抽象工厂模式:工厂方法模式通过引⼊工厂等级结构，解决了简单工厂模式中工厂类职责太重的问 题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势 必会增加系统的开销。此时，我们可以考虑将一些相关的产品组成⼀个产品族（位于不同产品等级 结构中功能相关联的产品组成的家族），由同一个工厂来统一生产，这就是抽象工厂模式的基本思 想。

#include <iostream>
#include <string>
#include <memory>

//创建水果类
class Fruit
{
public:
    virtual void name() = 0;
};

//创建苹果类
class Apple : public Fruit
{
public:
    void name() override
    {
        std::cout << "我是一个苹果！" << std::endl;
    }
};

//创建香蕉类
class Banana : public Fruit
{
public:
    void name() override
    {
        std::cout << "我是一个香蕉！" << std::endl;
    }
};

//创建动物类
class Animal
{
public:
    virtual void name() = 0;
};

//创建小猫类
class Cat : public Animal
{
public:
    void name() override
    {
        std::cout << "我是一只小猫！" << std::endl;
    }
};

//创建小狗类
class Dog : public Animal
{
public:
    void name() override
    {
        std::cout << "我是一只小狗！" << std::endl;
    }
};

//创建工厂类
class Factory
{
public:
    virtual std::shared_ptr<Fruit> createFruit(const std::string& name) = 0;
    virtual std::shared_ptr<Animal> createAnimal(const std::string& name) = 0;

};

//创建水果工厂
class FruitFactory : public Factory
{
public:
    std::shared_ptr<Fruit> createFruit(const std::string& name) override 
    {
        if(name == "苹果") //只创建了两种水果
        {
            return std::make_shared<Apple>();
        }
        else 
        {
            return std::make_shared<Banana>();
        }
    }

    std::shared_ptr<Animal> createAnimal(const std::string& name) override
    {
        return std::shared_ptr<Animal>();
    }

};

//创建动物工厂
class AnimalFactory : public Factory
{
public:
    std::shared_ptr<Fruit> createFruit(const std::string& name) override
    {
        return std::shared_ptr<Fruit>();
    }


    std::shared_ptr<Animal> createAnimal(const std::string& name) override 
    {
        if(name == "小猫") //只创建了两种动物
        {
            return std::make_shared<Cat>();
        }
        else 
        {
            return std::make_shared<Dog>();
        }
    }
};

class FactoryProducer //工厂生产者类
{
public:
    static std::shared_ptr<Factory> getFactory(const std::string& name)
    {
        if(name == "水果")
        {
            return std::make_shared<FruitFactory>();
        }
        if(name == "动物")
        {
            return std::make_shared<AnimalFactory>();
        }

        return std::shared_ptr<Factory>();
    }
};


int main()
{
    std::shared_ptr<Factory> FF = FactoryProducer::getFactory("水果"); //创建一个水果工厂
    std::shared_ptr<Fruit> fruit = FF->createFruit("苹果"); //创建一个苹果对象
    fruit->name();
    fruit = FF->createFruit("香蕉");
    fruit->name();

    std::shared_ptr<Factory> AF = FactoryProducer::getFactory("动物"); //创建一个动物工厂
    std::shared_ptr<Animal> animal = AF->createAnimal("小猫");
    animal->name();
    animal = AF->createAnimal("小狗");
    animal->name();


    return 0;
}

抽象工厂模式适⽤于⽣产多个工厂系列产品衍生的设计模式，增加新的产品等级结构复杂，需要对原 有系统进行较⼤的修改，甚⾄需要修改抽象层代码，违背了“开闭原则”。