C++23种设计模式之工厂模式

//简单工厂模式，缺点当产品分类较多时，需要在工厂类中写太多的分类代码，显得冗余
#include <iostream>
#include <string>

using namespace std;


enum Tank_Type
{
    Tank_56,
    Tank_59
};

///简单工厂模式
//抽象类
class Tank
{
public:
    virtual const string &type() = 0;
    virtual auto value()->int = 0;
};

//具体产品类
class Tank56:public Tank
{
public:
    Tank56():Tank(),m_TankType("Tank56")
    {}
    const string& type() override
    {
        std::cout << m_TankType.data() << endl;
        return m_TankType;
    }

    auto value()->int override{
        return stoi(m_TankType.data(), 0, 10);
    }
private:
    std::string m_TankType;
};

class Tank59:public Tank
{
public:
    Tank59():Tank(),m_TankType("Tank59")
    {}
    const string& type() override
    {
        std::cout << m_TankType.data() << endl;
        return m_TankType;
    }
    auto value()->int override{
        return stoi(m_TankType.data(), 0, 10);
    }
private:
    std::string m_TankType;
};

class Factory
{
public:
    static Tank* createTank(Tank_Type TankType)
    {
        switch(TankType)
        {
        case Tank_56:
            return new Tank56();
        case Tank_59:
            return new Tank59();
        default:
            return nullptr;
        }
    }
};

int main()
{
    Tank* pTank = Factory::createTank(Tank_56);
    pTank->type();
    Tank* pTank2 = Factory::createTank(Tank_59);
    pTank2->type();
    return 0;
}

//输出：
Tank56
Tank59


///工厂生产模式，就是将简单工厂模式的工厂类抽象化，只是给出了生产产品的接口，需要再实现不同的工厂类生产具体的产品。缺点：当产品分类太多时需要实现的具体工厂类会很多
//抽象类
class Tank{
public:
    virtual const string& type() = 0;
};

///产品类
class Tank56:public Tank
{
public:
    Tank56():Tank(),m_TankType("Tank56"){}
    const std::string& type() override
    {
        std::cout << m_TankType.data() << endl;
        return m_TankType;
    }
private:
    std::string m_TankType;
};

class Tank59:public Tank
{
public:
    Tank59():Tank(),m_TankType("Tank59"){}
    const std::string& type() override
    {
        std::cout << m_TankType.data();
        return m_TankType;
    }
private:
    std::string m_TankType;
};

///抽象工厂类
class Factory
{
public:
    virtual Tank* createTank() = 0;
};

///生产Tank56的工厂
class FactoryTank56:Factory
{
public:
    Tank* createTank() override
    {
        return  new Tank56;
    }
};

///生产Tank59的工厂
class FactoryTank59:Factory
{
public:
    Tank * createTank() override
    {
        return new Tank59;
    }
};

int main()
{
    FactoryTank56* pTank56 = new FactoryTank56();
    Tank* Tank56 = pTank56->createTank();
    Tank56->type();

    FactoryTank59* pTank59 = new FactoryTank59();
    Tank* Tank59 = pTank59->createTank();
    Tank59->type();
}

//输出：
Tank56
Tank59


///抽象工厂模式，当产品有不同分类，每种分类产品又有多种相似特征时，这时用抽象工厂模式会给编程带来便捷。缺点，当增加一个新系列的产品时，不仅需要实现具体的产品类，还需要增加一个新的创建接口，扩展相对困难。
//#include <list>
//#include <optional>

//bool bUsed = false;
///抽象物理战士类
class Fighter
{
public:
//    virtual auto create()->std::optional<list<std::string>> = 0;
    virtual const string type() = 0;
};

//物理战士类
class PhysicFighter:public Fighter
{
public:
    //    auto create()->std::optional<list<std::string>> override
    //    {
    //        std::list<std::string> List = {"1","2","3"};
    //        if(bUsed)
    //            return std::make_optional<list<std::string>>(List);
    //        return std::optional<list<std::string>>{};
    //    }
    PhysicFighter():Fighter(),m_Type("physic fighter"){}
    const string type() override
    {
        std::cout << m_Type.data() << endl;
        return m_Type;
    }
private:
    std::string m_Type;
};
//法术战士类
class MagicFighter:public Fighter
{
public:
    MagicFighter():Fighter(),m_Type("magic fighter"){}
    const string type() override
    {
        std::cout << m_Type.data() << endl;
        return m_Type;
    }
private:
    std::string m_Type;
};

//抽象刺客类
class Assassin
{
public:
    virtual const string type() = 0;
};

//物理刺客类
class PhysicAssassin:public Assassin
{
public:
    PhysicAssassin():Assassin(),m_Type("physic assassin"){}
    const string type() override
    {
        std::cout << m_Type.data() << endl;
        return m_Type;
    }
private:
    std::string m_Type;
};

//法术刺客类
class MagicAssassin:public Assassin
{
public:
    MagicAssassin():Assassin(),m_Type("magic assassin"){}
    const string type() override
    {
        std::cout << m_Type.data() << endl;
        return m_Type;
    }
private:
    std::string m_Type;
};

//抽象工厂类，定义创建接口
class Factory
{
public:
    virtual Fighter* createFighter() = 0;
    virtual Assassin* createAssassin() = 0;
};

//创建物理攻击的工厂
class PhysicFictory:public Factory
{
public:
    Fighter* createFighter() override{
        return new PhysicFighter();
    }
    Assassin* createAssassin() override{
        return new PhysicAssassin();
    }
};

//创建法术攻击的工厂
class MagicFictory:public Factory
{
public:
    Fighter* createFighter() override{
        return new MagicFighter();
    }
    Assassin* createAssassin() override{
        return new MagicAssassin();
    }
};

int main()
{
    PhysicFictory* phyFictory = new PhysicFictory;
    auto fighter1 = phyFictory->createFighter();
    fighter1->type();
    auto assassin1 = phyFictory->createAssassin();
    assassin1->type();

    MagicFictory* magFictory = new MagicFictory;
    auto fighter2 = magFictory->createFighter();
    fighter2->type();
    auto assassin2 = magFictory->createAssassin();
    assassin2->type();
    return 0;
}

//输出
physic fighter
physic assassin
magic fighter
magic assassin