//简单工厂模式,缺点当产品分类较多时,需要在工厂类中写太多的分类代码,显得冗余
#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