C/C++学习——工厂模式

---

一、简单工厂模式

简单工厂模式定义

工厂模式是一种常见的设计模式，它用于创建对象，但将对象的创建过程抽象出来，以便在不暴露对象的具体实现细节的情况下创建不同类型的对象。

代码示例

#include <iostream>
#include <memory>
/*
简单工厂模式：通过参数控制可以生产任何产品
优点：简单粗暴，直观易懂
缺点：1、所有东西生产在一起，产品太多会导致代码量庞大
      2、开闭原则遵循（开放拓展、关闭修改）的不是太好，要新增产品就必须修改工厂方法
*/


//创建一个抽象基类
class Fruit
{
    public:
        //构建一个纯虚函数
        virtual void name() = 0;
};

//创建一个子类，继承基类
class Apple : public Fruit
{
    public:
        void name() override
        {
            std::cout << "我是一个苹果\n";
        }
};

class Banana : public Fruit
{
    public:
        void name() override
        {
            std::cout << "我是一个香蕉\n";
        }
};

class FruitFactory
{
    public:
        // 静态成员函数，返回值为一个智能指针，函数名为create
        static std::shared_ptr<Fruit> create(const std::string &name)
        {
            if(name == "苹果")
            {
                return std::make_shared<Apple>(); //创建Apple类型的对象
            }
            else
            {
                return std::make_shared<Banana>();
            }
        }
};

int main()
{
    Apple a; //实例化对象
    a.name();

    std::shared_ptr<Fruit> fruit = FruitFactory::create("苹果");
    fruit->name();
    fruit = FruitFactory::create("香蕉");
    fruit->name();
    return 0;
}

总结

简单工厂模式的优缺点：
优点：简单粗暴，直观易懂
缺点：1、所有东西生产在一起，产品太多会导致代码量庞大
2、开闭原则遵循（开放拓展、关闭修改）的不是太好，要新增产品就必须修改工厂方法

二、抽象工厂模式

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

代码示例

#include <iostream>
#include <memory>
using namespace std;

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

class Dog :public Animal
{
    public:
        void name() override
        {
            cout << "我是一只小狗！\n" << endl; 
        }
};

class Cat :public Animal
{
    public:
        void name() override
        {
            cout << "我是一只小猫！\n" << endl; 
        }
};

class Fruit
{   
    public:
        virtual void name() = 0;
};

class Banana :public Fruit
{
    public:
        void name() override
        {
            cout << "这是一只香蕉！\n" << endl; 
        }
};

class Apple :public Fruit
{
    public:
        void name() override
        {
            cout << "这是一只苹果！\n" << endl; 
        }
};

class Factory
{
    public:
        virtual shared_ptr<Fruit> getFruit(const string &name) =0;
        virtual shared_ptr<Animal> getAnimal(const string &name)=0;
};

class AnimalFactory : public Factory
{
    public:
        shared_ptr<Fruit> getFruit(const string &name)
        {
            return make_shared<Fruit>(); //返回一个空指针
        }
        shared_ptr<Animal> getAnimal(const string &name)
        {
            if (name == "小狗")
            {
                return make_shared<Dog>();
            }
            else
            {
                return make_shared<Cat>();
            }
        }

};

class FruitFactory : public Factory
{
    public:
        shared_ptr<Fruit> getFruit(const string &name)
        {
            if(name == "香蕉")
            {
                return make_shared<Banana>();
            }
            else
            {
                return make_shared<Apple>();
            }
        }
        shared_ptr<Animal> getAnimal(const string &name)
        {
            return make_shared<Animal>();
        }
};

//选择工厂类
class FactoryProducer
{
    public:
        static shared_ptr<Factory> create(const string &name)
        {
            if(name == "水果")
            {
                return make_shared<FruitFactory>();
            }
            else
            {
                return make_shared<AnimalFactory>();
            }
        }
};

int main()
{   
    shared_ptr<Factory> ff = FactoryProducer::create("水果");
    shared_ptr<Fruit> fruit = ff->getFruit("水果");
    fruit->name();

    fruit = ff->getFruit("香蕉");
    fruit->name();

    return 0;
}