工厂模式

工厂模式

1.  工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式三种

简单工厂模式

1. 简单工厂模式包含两部分工厂类、产品类(工厂函数)
2. 同一个工厂类(工厂函数)通过传递不同的参数可以生产不同类型的产品(如不同品牌的洗衣机)
3. 简单工厂模式主要利用基类指针或引用可以指向派生类对象的特性
4. 工厂模式的缺点：当需要生产新品牌的洗衣机，需要修改工厂类，这违反了软件的开放封闭原则：软件实体(类、模块、函数)可以扩展，但不能修改

查看代码

enum WasherBrand{Midea = 0, Haier, Gree};
class Washer
{
public:
    virtual WasherBrand brand() = 0;
};
class MideaWasher:public Washer
{
public:
    MideaWasher()
    {
        cout << "Midea Washer!" << endl;
    }
    WasherBrand brand()
    {
        return Midea;
    }
    ~MideaWasher(){}
};
class HaierWasher :public Washer
{
public:
    HaierWasher()
    {
        cout << "Haier Washer!" << endl;
    }
    WasherBrand brand()
    {
        return Haier;
    }
    ~HaierWasher() {}
};
class GreeWasher :public Washer
{
public:
    GreeWasher()
    {
        cout << "Gree Washer!" << endl;
    }
    WasherBrand brand()
    {
        return Gree;
    }
    ~GreeWasher() {}
};

class WasherFactory
{
public:
    Washer* createwasher(WasherBrand brand)
    {
        switch (brand)
        {
        case Midea:
            return new MideaWasher();
        case Haier:
            return new HaierWasher();
        case Gree:
            return new GreeWasher();
        }
        return nullptr;
    }
};

工厂方法模式

1. 工厂方法模式解决了简单工厂模式生产新产品修改修改工厂类的不足，即工厂方法模式始终满足软件的开放封闭原则
2. 在工厂方法模式工厂类成为基类(虚基类)，实际的生产过程由多个继承工厂类的子类完成，如生产MideaWasher的子类等，这一点与简单工厂类是不同的，在简单工厂模式下，只有一个工厂类，根据不同的品牌生产不同品牌的洗衣机，而工厂方法模式中每一种品牌的洗衣机都有专门的生产工厂
3. 由于每个子工厂类只生产一种产品，因此每增加一种产品就要增加一种对应的子工厂类。

查看代码

enum WasherBrand{Midea = 0, Haier, Gree};
class Washer
{
public:
    virtual WasherBrand brand() = 0;
};
class MideaWasher:public Washer
{
public:
    MideaWasher()
    {
        cout << "Midea Washer!" << endl;
    }
    WasherBrand brand()
    {
        return Midea;
    }
    ~MideaWasher(){}
};
class HaierWasher :public Washer
{
public:
    HaierWasher()
    {
        cout << "Haier Washer!" << endl;
    }
    WasherBrand brand()
    {
        return Haier;
    }
    ~HaierWasher() {}
};
class GreeWasher :public Washer
{
public:
    GreeWasher()
    {
        cout << "Gree Washer!" << endl;
    }
    WasherBrand brand()
    {
        return Gree;
    }
    ~GreeWasher() {}
};

class WasherFactory
{
public:
    virtual Washer* createwasher() = 0;
};
class MideaWasherFactory : public WasherFactory
{
public:
    Washer* createwasher()
    {
        return new MideaWasher();
    }
};

class HaierWasherFactory : public WasherFactory
{
public:
    Washer* createwasher()
    {
        return new HaierWasher();
    }
};
class GreeWasherFactory : public WasherFactory
{
public:
    Washer* createwasher()
    {
        return new GreeWasher();
    }
};

抽象工厂类

1. 工厂方法类中的每个具体的子工厂只能生产一种产品，如Washer，假如Midea、Haier、Gree此时不仅生产洗衣机还生产冰箱Refrigerator，此时每个子工厂就不能只生产洗衣机了，还需要同时生产冰箱
2. 抽象工厂模式提供一个纯虚基类(接口)可以创建多个产品族的产品对象，如Midea可以生产MideaWasher、MideaRefrigerator等

查看代码

enum Brand{Midea = 0, Haier, Gree};
class Washer
{
public:
    virtual Brand brand() = 0;
};
class MideaWasher:public Washer
{
public:
    MideaWasher()
    {
        cout << "Midea Washer!" << endl;
    }
    Brand brand()
    {
        return Midea;
    }
    ~MideaWasher(){}
};
class HaierWasher :public Washer
{
public:
    HaierWasher()
    {
        cout << "Haier Washer!" << endl;
    }
    Brand brand()
    {
        return Haier;
    }
    ~HaierWasher() {}
};
class GreeWasher :public Washer
{
public:
    GreeWasher()
    {
        cout << "Gree Washer!" << endl;
    }
    Brand brand()
    {
        return Gree;
    }
    ~GreeWasher() {}
};


class Refrigerator
{
public:
    virtual Brand brand() = 0;
};
class MideaRefrigerator :public Refrigerator
{
public:
    MideaRefrigerator()
    {
        cout << "Midea Refrigerator!" << endl;
    }
    Brand brand()
    {
        return Midea;
    }
    ~MideaRefrigerator() {}
};
class HaierRefrigerator :public Refrigerator
{
public:
    HaierRefrigerator()
    {
        cout << "Haier Refrigerator!" << endl;
    }
    Brand brand()
    {
        return Haier;
    }
    ~HaierRefrigerator() {}
};
class GreeRefrigerator :public Refrigerator
{
public:
    GreeRefrigerator()
    {
        cout << "Gree Refrigerator!" << endl;
    }
    Brand brand()
    {
        return Gree;
    }
    ~GreeRefrigerator() {}
};

class Factory
{
public:
    virtual Washer* createwasher() = 0;
    virtual Refrigerator* createrefrigerator() = 0;
};
class MideaFactory : public Factory
{
public:
    Washer* createwasher()
    {
        return new MideaWasher();
    }
    Refrigerator* createrefrigerator()
    {
        return new MideaRefrigerator();
    }
};

class HaierFactory : public Factory
{
public:
    Washer* createwasher()
    {
        return new HaierWasher();
    }
    Refrigerator* createrefrigerator()
    {
        return new HaierRefrigerator();
    }
};
class GreeFactory : public Factory
{
public:
    Washer* createwasher()
    {
        return new GreeWasher();
    }
    Refrigerator* createrefrigerator()
    {
        return new GreeRefrigerator();
    }
};

总结

1. 简单工厂模式在新增产品时需要修改工厂类，违背了开放封闭原则
2. 工厂方法类和抽象工厂类在新增产品时都需要新增一个对应的具体的产品类(工厂子类)，增加了代码的编写量

参考文献

1. 工厂模式（C++实现）
2. C++ 深入浅出工厂模式（初识篇）