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

（二）工厂模式分类

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

#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;
}

运行结果如下：

【小结】

???法：定义?个创建对象的接?，但是由?类来决定创建哪种对象，使?多个??分别?产指定 的固定产品

优点：

• 1. 减轻了??类的负担，将某类产品的?产交给指定的??来进?
• 2. 开闭原则遵循较好，添加新产品只需要新增产品的??即可，不需要修改原先的??类

缺点：

• 对于某种可以形成?组产品族的情况处理较为复杂,需要创建?量的??类

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

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;
}

运行结果如下：