93、⼯⼚模式

简单工厂模式：

就是建⽴⼀个⼯⼚类，对实现了同⼀接⼝的⼀些类进⾏实例的创建。简单⼯⼚模式的实质是由 ⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类（这些产品类继承⾃⼀个⽗类或 接⼝）的实例。

#include <iostream>
#include <pthread.h>
using namespace std;
 
//产品类（抽象类，不能实例化）
class Product{
public:
    Product(){};
    virtual void show()=0;  //纯虚函数
};
 
class productA : public Product{
public:
    productA(){};
    void show(){ std::cout << "product A create!" << std::endl; };
    ~productA(){};
};
 
class productB : public Product{
public:
    productB(){};
    void show(){ std::cout << "product B create!" << std::endl; };
    ~productB(){};
};
 
class simpleFactory{ // ⼯⼚类
public:
    simpleFactory(){};
    Product* product(const string str){
        if (str == "productA")
            return new productA();
        if (str == "productB")
           return new productB();
        return NULL;
    };
};
 
int main(){
    simpleFactory obj; // 创建⼯⼚
    Product* pro; // 创建产品
    pro = obj.product("productA");
    pro->show(); // product A create!
    delete pro;
 
    pro = obj.product("productB");
    pro->show(); // product B create!
    delete pro;
    return 0;
}

⼯⼚模式⽬的就是代码解耦，如果我们不采⽤⼯⼚模式，如果要创建产品 A、 B，通常做法采 ⽤⽤ switch...case语句，那么想⼀想后期添加更多的产品进来，我们不是要添加更多的switch...case 吗？这样就很麻烦，⽽且也不符合设计模式中的开放封闭原则。

为了进⼀步解耦，在简单⼯⼚的基础上发展出了抽象⼯⼚模式，即连⼯⼚都抽象出来，实现了 进⼀步代码解耦。

代码如下：

#include <iostream>
#include <pthread.h>
using namespace std;
 
//产品类（抽象类，不能实例化）
class Product{
public:
    Product(){}
    virtual void show()=0;  //纯虚函数
};
 
class Factory{//抽象类
public:
    virtual Product* CreateProduct()=0;//纯虚函数
};
//产品A
class ProductA:public Product{
public:
    ProductA(){}
    void show(){ std::cout<<"product A create!"<<std::endl; };
};
 
//产品B
class ProductB:public Product{
public:
    ProductB(){}
    void show(){ std::cout<<"product B create!"<<std::endl; };
};
 
//⼯⼚类A，只⽣产A产品
class FactorA: public Factory{
public:
    Product* CreateProduct(){
        Product* product_ = nullptr;
        product_ = new ProductA();
        return product_;
    }
};
//⼯⼚类B，只⽣产B产品
class FactorB: public Factory{
public:
    Product* CreateProduct(){
        Product* product_ = nullptr;
        product_ = new ProductB();
        return product_;
    }
};
 
int main(){
    Product* product_ = nullptr;
    auto MyFactoryA = new FactorA();
    product_ = MyFactoryA->CreateProduct();// 调⽤产品A的⼯⼚来⽣产A产品
    product_->show();
    delete product_;
 
    auto MyFactoryB=new FactorB();
    product_ = MyFactoryB->CreateProduct();// 调⽤产品B的⼯⼚来⽣产B产品
    product_->show();
    delete product_;
 
    return 0;
}
//输出 
//product A create! product B create!