类写的不规范，原因： 缩短篇幅，实际中请不要这样写。 欢迎指正

 

　　工厂模式，如其名，想象下现实生活中的工厂，比如Apple的组装工厂，小米产品的组装工厂，华为设备的组装工厂。对我们用户而言，不需要知道他到底是怎么组装的，几道工序，时间长短，这些用户都不需要关心。 

 

1、分类

　　A、 简单工厂， 生产一一种产品， 只生产电视，只生产手机

　　B、 工厂方法，生产一系列产品， 生产一系列电视、生产一些列手机

　　C、 抽象工厂，生产一个品牌产品，生产该品牌下的所有商品，电视，手机都生产。

 

2、简单工厂

　　一句话： 产品来自工厂。这里以 XM 和 TCL 为例

　　A、先定义商品类

class mtv
{
public:
    // 电视机具有的基本功能
    virtual void play() = 0;
};

　　B、TCL 电视，继承自电视类

// tcl电视
class tv_tcl : public mtv
{
public:
    void play() { cout << "\n\n tcl is running"; }
};

　　C、小米电视继承自电视类

// 小米电视
class tv_xm : public mtv
{
public:
    void play() { cout << "\n\n xm is running"; }
};

　　D、工厂类，生产电视机的。设定一个序号， 1-小米电视， 2-tcl 电视

// 电视机工厂
class mtv_factory
{
public:
    mtv *get_tv(const int index )
    {
        if (2 == index)
            return new tv_xm;
        else if (1 == index)
            return new tv_tcl;
        else
            throw "it cannot find the tv";
    }
};

　　　　齐活儿，电视机和工厂准备好了，下面开始生产电视。调用示例，需要什么电视就向工厂传值：

void call_simple_factory()
{
    std::unique_ptr<mtv_factory> ptvfact(new mtv_factory);
    if (nullptr == ptvfact)
    {
        cout << "ptvfact = nullptr\n\n";

        return;
    }

    std::unique_ptr<mtv> ptv(ptvfact->get_tv(2));
    if (nullptr == ptv)
    {
        cout << "ptv = nullptr\n\n";

        return;
    }

    ptv->play();
}

　　工厂就一个，负责生产所有的电视。这时，需要增加一种新产品电视小米，就需要添加小米电视机类和工厂添加生产小米的流水线。 新增一种电视产品就需要额外增加代码。

　　优点也很明显，各模块之间保持一定的独立， 尽量降低耦合

 

3、工厂方法

　　一句话： 所有的产品都需要来自自己对应工厂。 看下面的例子。这里，以海尔电视为例。需要用到的有： 工厂和产品

　　A、电视类， 电视可以播放节目

class tv_brand
{
public:
    virtual void play() = 0;
};

　　B、海尔电视类， 继承电视类

class tv_brand_haier : public tv_brand
{
public:
    void play()
    {
        cout << "\n\n haier tv is running \n";
    }
};

　　C、现实中，电视机生产应该是在工厂内完成的，这里，定义一个电视机生产的工厂，专门生产电视

// 总的工厂还是生产电视机
class tv_factory 
{
public:
    virtual tv_brand *get_tv_brand() = 0;
};

　　D、海尔电视机 也需要从 海尔电视机工厂 生产得到，下面定义了海尔电视机工厂，继承自上面C中的电视机工厂

class tv_fact_haier : public tv_factory
{
public:
    tv_brand *get_tv_brand()
    {
        return new tv_brand_haier;
    }
};

　　齐活儿，电视机工厂有了，电视机工厂也有了电视机产品的设计图，可以开始生产了。

void call_tv_new()
{
    std::unique_ptr<tv_factory> phaierfact(new tv_fact_haier);
    if (!phaierfact)
    {
        cout << "\n\n 总海尔工厂创建失败 \n\n";
        return;
    }

    // 创建工厂对象
    std::unique_ptr<tv_brand> ptv_haier(phaierfact->get_tv_brand());
    if (!ptv_haier)
    {
        cout << "\n\n 海尔工厂创建对象失败 \n\n";
        return;
    }

    // 播放节目
    ptv_haier->play();
}

　　调用时，告诉电视机工厂，说，我我需要海尔电视机。 想比 简单工厂， 调用更加简洁了。工厂再也不用判断了，而且代码更加清晰明了。

 

4、抽象工厂

　　还是以海尔为例，现在业务做大了，不仅有电视业务，还有空调业务。于是建立了电视工厂和空调工厂

　　A、 电视及类

// 每台电视机都可以播放节目
class tv_brand
{
public:
    virtual void play() = 0;
};

　　B、海尔电视机类，继承电视类，

class tv_brand_haier : public tv_brand
{
public:
    void play()
    {
        cout << "\n\n haier tv is running \n";
    }
};

　　C、电视机工厂类

class tv_factory 
{
public:
    virtual tv_brand *get_tv_brand() = 0;
};

　　D、海尔电视机工厂类，继承电视机工厂类，生产电视机

class tv_fact_haier : public tv_factory
{
public:
    tv_brand *get_tv_brand()
    {
        return new tv_brand_haier;
    }
};

　　E、空调类

// air conditioner
class air_conditioner
{
public:
    virtual void change_temperature() = 0;
};

　　F、海尔空调类

class air_conditioner_haier : public air_conditioner
{
public:
    void change_temperature()
    {
        cout << "\n\n haier airconditioner is running\n\n";
    }
};

　　G、空调工厂类

// 空调工厂负责生产对象
class factory_airditioner
{
public:
    virtual air_conditioner *get_air_conditioner() = 0;
};

　　H、海尔空调工厂类，继承空调工厂类生产海尔空调

class factory_airditioner_haier : public factory_airditioner
{
public:
    air_conditioner *get_air_conditioner()
    {
        return new air_conditioner_haier;
    }
};

　　I、到此，所有的产品和所有产品对应的工厂准备完毕，海尔需要一个总厂，将其聚拢一起，如下

// haier总工厂
class factory_haier
{
public:
    // 空调工厂
    factory_airditioner * get_air_conditioner()
    {
        return new factory_airditioner_haier;
    }

    // tv工厂
    tv_factory            *get_tv()
    {
        return new tv_fact_haier;
    }
};

　　J、总厂和分工厂也都建好了，分工厂也有了自己的产品样版。下面开始生产商品

void call_haier_facotry()
{
    std::unique_ptr<factory_haier> phaier_factory(new factory_haier);
    if (!phaier_factory)
    {
        cout << "\n\n 海尔电器总厂创建失败 \n\n";
        return;
    }

    // 海尔电视工厂
    std::unique_ptr<tv_factory> ptv_haier_fact(phaier_factory->get_tv());

    // 海尔空调工厂
    std::unique_ptr<factory_airditioner> pair_con_haier_fact(phaier_factory->get_air_conditioner());


    if (!ptv_haier_fact)
    {
        cout << "\n\n\n 海尔电视机工厂创建失败\n\n";
    }
    else
    {
        std::unique_ptr<tv_brand> phaier_tv(ptv_haier_fact->get_tv_brand());
        if (!phaier_tv)
            cout << "\n\n 海尔电视生产失败\n\n";
        else
            phaier_tv->play();
    }

    if (!pair_con_haier_fact)
    {
        cout << "\n\n\n 海尔空调工厂创建失败\n\n";
    }
    else
    {
        std::unique_ptr<air_conditioner> phaier_air_con(pair_con_haier_fact->get_air_conditioner());
        if (!phaier_air_con)
            cout << "\n\n 海尔空调生产失败\n\n";
        else
            phaier_air_con->change_temperature();
    }
}

 

5、总结

　　工厂模式需要写相对较多的代码，但是结构清晰，很容易维护。