C++设计模式之工厂模式【三种模式】

1、静态工厂模式

//优点：可以根据产品的名字生产出对应的产品

//缺点：

//1、违反了单一职责原则

//2、违反了开放闭合原则

//3、违反了依赖导致原则

当我还有产品要增加时，必须去修改factory的代码，这样其实是不太好的。

 

#include <iostream>
#include <string>
#include <memory>

using std::unique_ptr;
using std::string;
using std::cout;
class Product
{
public:
    virtual void show() = 0;
    // virtual ~Product() = 0;
};

class ProductA : public Product
{
public:
    ProductA()
    {
        cout << "ProductA...\n";
    }

    void show() override
    {
        cout << "ProductA...\n";
    }
};

class ProductB : public Product
{
public:
    ProductB()
    {
        cout << "ProductB...\n";
    }

    void show() override
    {
        cout << "ProductB...\n";
    }
};

class ProductC : public Product
{
public:
    ProductC()
    {
        cout << "ProductC...\n";
    }

    void show() override
    {
        cout << "ProductC...\n";
    }
};

class Factory
{
public:
    static Product* createProduct(const string& productName)
    {
        if(productName == "A") return new ProductA();
        if(productName == "B") return new ProductB();
        if(productName == "C") return new ProductC();

        return nullptr;
    }
};


int main(int argc, char const *argv[])
{
    unique_ptr<Product> p1(Factory::createProduct("C"));
    unique_ptr<Product> p2(Factory::createProduct("B"));
    unique_ptr<Product> p3(Factory::createProduct("A"));
    return 0;
}

2、工厂方法 

//工厂模式（工厂方法）

//优点：

//1、遵循了单一职责原则

//2、遵循了开放闭合原则

//3、遵循了依赖导致原则

//

//缺点:工厂的数量会随着产品的增加而急剧上升

#include <iostream>
#include <memory>

using std::cout;
using std::unique_ptr;

class Product
{
public:
    virtual void show() = 0;
};

class ProductA : public Product
{
public:
    ProductA()
    {
        cout << "ProductA()..\n";
    }
    void show()
    {
        cout << "ProductA~\n";
    }
};

class ProductB : public Product
{
public:
    ProductB()
    {
        cout << "ProductB()..\n";
    }
    void show()
    {
        cout << "ProductB~\n";
    }
};

class ProductC : public Product
{
public:
    ProductC()
    {
        cout << "ProductC()..\n";
    }
    void show()
    {
        cout << "ProductC~\n";
    }
};

class Factory
{
public:
    virtual Product *create() = 0;
};

class FactoryA : public Factory
{
public:
    Product *create()
    {
        cout << "FactoryA~\n";
        return new ProductA();
    }
};

class FactoryB : public Factory
{
public:
    Product *create()
    {
        cout << "FactoryB~\n";
        return new ProductB();
    }
};

class FactoryC : public Factory
{
public:
    Product *create()
    {
        cout << "FactoryC~\n";
        return new ProductC();
    }
};

int main(int argc, char const *argv[])
{
    // 创建A工厂
    unique_ptr<Factory> fA(new FactoryA());
    // 创建B工厂
    unique_ptr<Factory> fB(new FactoryB());
    // 创建C工厂
    unique_ptr<Factory> fC(new FactoryC());

    // 产品A
    unique_ptr<Product> pA(fA->create());
    pA->show();
    // 产品B
    unique_ptr<Product> pB(fB->create());
    pB->show();
    // 产品C
    unique_ptr<Product> pC(fC->create());
    pC->show();

    return 0;
}

3、抽象工厂方法

抽象工厂的执行流程是这样的，首先对产品分类，有3个小类属于A产品，有2个小类属于B产品，那么这时候就创建3个工厂，因为只有最多的产品有3类，意思就是有几类产品就要有几个工厂，工厂1专门创建第一类产品，工厂2专门创建第2类产品，工厂3专门创建第3类产品。

总之工厂里的函数的个数取决于产品的类数【纵向】，工厂的个数取决于某类产品最多的子类【横向】

#include <iostream>
#include <memory>

using std::cout;
using std::unique_ptr;

class ProductA
{
public:
    virtual void show() = 0;
};

class ProductA1 : public ProductA
{
public:
    void show()
    {
        cout << "ProductA1()..\n";
    }
};

class ProductA2 : public ProductA
{
public:
    void show()
    {
        cout << "ProductA2()..\n";
    }
};

class ProductB
{
public:
    virtual void show() = 0;
};

class ProductB1 : public ProductB
{
public:
    void show()
    {
        cout << "ProductB1()..\n";
    }
};
class ProductB2 : public ProductB
{
public:
    void show()
    {
        cout << "ProductB2()..\n";
    }
};

class Factory
{
public:
    virtual ProductA *createA() = 0;
    virtual ProductB *createB() = 0;
};

class Factory1 : public Factory
{
public:
    ProductA *createA()
    {
        cout << "Factory1() CREATE ProductA1..\n";
        return new ProductA1;
    }

    ProductB *createB()
    {
        cout << "Factory1() CREATE ProductB1..\n";
        return new ProductB1;
    }
};

class Factory2 : public Factory
{
    public:
    ProductA *createA()
    {
        cout << "Factory2() CREATE ProductA2..\n";
        return new ProductA2;
    }

    ProductB *createB()
    {
        cout << "Factory2() CREATE ProductB2..\n";
        return new ProductB2;
    }
};

int main(int argc, char const *argv[])
{
    // 工厂1
    unique_ptr<Factory> f1(new Factory1);
    // 工厂2
    unique_ptr<Factory> f2(new Factory2);


    // 产品1
    unique_ptr<ProductA> pA1(new ProductA1);
    unique_ptr<ProductB> pB1(new ProductB1);

    // 产品2
    unique_ptr<ProductA> pA2(new ProductA2);
    unique_ptr<ProductB> pB2(new ProductB2);

    pA1->show();
    pA2->show();
    pB1->show();
    pB1->show();

    return 0;
}