工厂模式

回到目录

参考链接：

• 链接一
• 链接二

简介

UML类图

简单工厂模式

#include <iostream>

using namespace std;

/* 摘抄自知乎
 * 设计模式的一个重要原则就是：别改代码，只需要添代码
 */

/* 
 * 简单工厂
 * 优点：简单
 * 缺点：每增加一个类，都需要修改工厂类，违背了不改代码的原则
 */

//产品抽象类
class Product
{
public:
    virtual void show() = 0;
    virtual ~Product() {}
};

//产品A
class ProductA : public Product
{
public:
    virtual void show(){cout << "ProductA" << endl;};
    virtual ~ProductA() {}
};
//产品B
class ProductB : public Product
{
public:
    virtual void show(){cout << "ProductB" << endl;};
    virtual ~ProductB() {}
};

//工厂类
enum PRODUCT_TYPE {PRODUCT_A = 0, PRODUCT_B};
class Factory
{
public:
    Product *create(PRODUCT_TYPE type) {
        switch(type) {
        case PRODUCT_A: return new ProductA; break;
        case PRODUCT_B: return new ProductB; break;
        default: return NULL; break;
        }
    }

};

int main()
{
    Factory factoty;
    Product *productA_ptr = factoty.create(PRODUCT_A);
    productA_ptr->show();
    delete productA_ptr;

    Product *productB_ptr = factoty.create(PRODUCT_B);
    productB_ptr->show();
    delete productB_ptr;

    return 0;
}

工厂方法模式

#include <iostream>

using namespace std;

/* 
 * 工厂方法
 * 优点：遵循了不改代码的原则
 * 缺点：一条生产线只能一个产品
 */

//产品抽象类
class Product
{
public:
    virtual void show() = 0;
    virtual ~Product() {};
};

//产品A
class ProductA : public Product
{
public:
    virtual void show(){cout << "ProductA" << endl;}
    virtual ~ProductA() {};
};
//产品B
class ProductB : public Product
{
public:
    virtual void show(){cout << "ProductB" << endl;}
    virtual ~ProductB() {};
};
//工厂抽象类
class Factory
{
public:
    virtual Product *CreateProduct() = 0;
    virtual ~Factory() {}
};

//产品A工厂
class FactoryProductA : Factory
{
public:
    Product *CreateProduct() {return new ProductA();}
    virtual ~FactoryProductA() {}
};
//产品B工厂
class FactoryProductB : Factory
{
public:
    Product *CreateProduct() {return new ProductB();}
    virtual ~FactoryProductB() {}
};

int main()
{
    //开设工厂A
    FactoryProductA factoryProductA;
    //A产品由工厂A生产
    Product *productA_ptr = factoryProductA.CreateProduct();
    //A产品展示
    productA_ptr->show();
    delete productA_ptr;

    FactoryProductB factoryProductB;
    Product *productB_ptr = factoryProductB.CreateProduct();
    productB_ptr->show();
    delete productB_ptr;

    return 0;
}

抽象工厂模式

#include <iostream>

using namespace std;

/* 
 * 抽象工厂
 * 优点：遵循了不改代码的原则
 * 缺点：增加一类，需要加很多个类，代码量比较大
 */

//A产品抽象类
class ProductA
{
public:
    virtual void show() = 0;
    virtual ~ProductA() {};
};

//A产品
class ProductA1 : public ProductA
{
public:
    virtual void show(){cout << "ProductA" << endl;}
    virtual ~ProductA1() {};
};

//B产品抽象类
class ProductB
{
public:
    virtual void show() = 0;
    virtual ~ProductB() {};
};

//B产品
class ProductB1 : public ProductB
{
public:
    virtual void show(){cout << "ProductB" << endl;}
    virtual ~ProductB1() {};
};


//工厂抽象类，可生产产品A和产品B
class Factory
{
public:
    virtual ProductA *CreateProductA() = 0;
    virtual ProductB *CreateProductB() = 0;
    virtual ~Factory() {}
};

//生产AB产品的工厂
class FactoryProduct : Factory
{
public:
    ProductA *CreateProductA() {return new ProductA1();}
    ProductB *CreateProductB() {return new ProductB1();}
    virtual ~FactoryProduct() {}
};

int main()
{
    //开设工厂A
    FactoryProduct factoryProduct;
    //A产品由工厂A生产
    ProductA *productA_ptr = factoryProduct.CreateProductA();
    //A产品展示
    productA_ptr->show();
    delete productA_ptr;

    ProductB *productB_ptr = factoryProduct.CreateProductB();
    productB_ptr->show();
    delete productB_ptr;

    return 0;
}