抽象工厂模式

简单工厂和工厂模式都是指的是一类相同的类。

抽象工厂是针对的多个类的对象的组合。

提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

实现：分别为火车和飞机制造发动机和轮胎，火车和飞机用不同的发动机和轮胎。

//抽象产品 发动机
class Engine
{
public:
    virtual void makeEngine() = 0;
};
//具体产品 火车发动机
class TrainEngine :public Engine
{
public:
    void makeEngine(){cout << "Train Engine" << endl;}
};
//具体产品 飞机发动机
class PlaneEngine :public Engine
{
public:
    void makeEngine(){cout << "Plane Engine" << endl;}
};

//抽象产品 轮胎
class Tyre
{
public:
    virtual void makeTyre() = 0;
};
//具体产品 火车轮胎
class TrainTyre :public Tyre
{
public:
    void makeTyre(){cout << "Train Tyre" << endl;}
};
//具体产品 飞机轮胎
class PlaneTyre :public Tyre
{
public:
    void makeTyre(){cout << "Plane Tyre" << endl;}
};

//抽象工厂 
class Factory
{
public:
    virtual Engine* cerateEngine() = 0;
    virtual Tyre* createTyre() = 0;
};
//具体工厂 火车工厂
class TrainFactory :public Factory
{
    Engine* cerateEngine()
    {
        Engine* trainEngine = new TrainEngine();
        return trainEngine;
    }
    Tyre* createTyre()
    {
        Tyre* trainTyre = new TrainTyre();
        return trainTyre;
    }
};
//具体工厂 飞机工厂
class PlaneFactory :public Factory
{
    Engine* cerateEngine()
    {
        Engine* planeEngine = new PlaneEngine();
        return planeEngine;
    }
    Tyre* createTyre()
    {
        Tyre* planeTyre = new PlaneTyre();
        return planeTyre;
    }
};

int main()
{
    Factory* factory = new TrainFactory();

    Engine* engine = factory->cerateEngine();
    Tyre* tyre = factory->createTyre();
    engine->makeEngine();
    tyre->makeTyre();

    factory = new PlaneFactory();
    engine = factory->cerateEngine();
    tyre = factory->createTyre();
    engine->makeEngine();
    tyre->makeTyre();
    
    delete factory;
    delete engine;
    delete tyre;
    return 0;
}