C++工厂模式

不念不忘少年蓝@ 2024-04-17 15:15 65阅读 0赞

工厂模式分为3种，即简单工厂模式、工厂方法模式、抽象工厂模式，C++的工厂模式主要利用到虚函数。

# 简单工厂模式 #

简单工厂模式有一个工厂，可以生产多个产品，包含两个接口，一个是产品类的，一个是工厂类的。  
产品类需要有一个基类，基类中的具体产品实现需要是个纯虚函数，这样一来，产品的子类必须要重写具体的产品实现，实现不同的功能。  
产品类封装完成后，还需要一个工厂类，工厂类对产品类再次封装，最终实现**由一个工厂对象决定创建出哪一种产品类的实例**。

//简单工厂模式
    #include<iostream>
    using namespace std;
    
    //产品的基类
    class Product{
        
    public:
       //基类中的纯虚函数
    	virtual int operation(int a, int b) = 0;
    };
    //产品的子类Add
    class Product_Add : public Product{
        
    public:
    	int operation(int a, int b){
        
    		return a + b;
    	}
    };
    //产品的子类Mul
    class Product_Mul : public Product{
        
    public:
    	int operation(int a, int b){
        
    		return a * b;
    	}
    };
    //工厂
    class Factory{
        
    public:
    	Product* Create(int i){
        
    		switch (i){
        
    		case 1:
    			return new Product_Add;
    			break;
    		case 2:
    			return new Product_Mul;
    			break;
    		default:
    			break;
    		}
    	}
    };
    
    int main()
    {
        
    	Factory *factory = new Factory();
    	int add_result = factory->Create(1)->operation(1, 2);
    	int mul_result = factory->Create(2)->operation(1, 2);
    	cout <<"op_add：" <<add_result << endl;
    	cout <<"op_multiply：" << mul_result << endl;
    		getchar();
    	return 0;
    }

上面的代码中实现了两个产品，一个“加”，一个“乘”，选择哪一种操作完全由工厂类封装的`Create()`来决定。  
但是简单工厂模式违背开放-封闭原则，即对扩展开放，对修改封闭。因为要添加第三个产品“减”时，需要修改工厂类的代码。

# 工厂方法模式 #

由于简单工厂模式的弊端，发展出了工厂方法模式。工厂方法模式有多个工厂，但是每个工厂只对应一个产品。此时工厂类和产品类都有基类，并且都包含一个纯虚函数。

#include<iostream>
    
    using namespace std;
    
    //工厂方法模式
    class Product{
        
    public:
    	virtual int operation(int a, int b) = 0;
    };
    
    class Product_Add : public Product{
        
    public:
    	int operation(int a, int b){
        
    		return a + b;
    	}
    };
    
    class Product_Mul : public Product{
        
    public:
    	int operation(int a, int b){
        
    		return a * b;
    	}
    };
    
    class Factory{
        
    public:
    	virtual Product* Create() = 0;
    };
    
    
    class Factory_Add : public Factory{
        
    public:
    	Product* Create(){
        
    		return new Product_Add;
    	}
    };
    
    class Factory_Mul : public Factory{
        
    public:
    	Product* Create(){
        
    		return new Product_Mul;
    	}
    };
    
    int main()
    {
        
    	Factory_Add *factory_add = new Factory_Add();
    	Factory_Mul *factory_mul = new Factory_Mul();
    	int add_result = factory_add->Create()->operation(1, 2);
    	int mul_result = factory_mul->Create()->operation(1, 2);
    	cout << "op_add：" << add_result << endl;
    	cout << "op_multiply：" << mul_result << endl;
    	getchar();
    	return 0;
    }

当增加一个新产品时，同时增加一个新工厂。增加新工厂属于扩展，不会修改以前工厂类和产品类的任何代码。

# 抽象工厂模式 #

在工厂方法模式的基础上，如果一个工厂想要生产多个产品，就有了抽象工厂模式，抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。抽象工厂模式其实是简单工厂模式和工厂方法模式的组合。

#include<iostream>
    using namespace std;
    
    //抽象工厂模式
    class Product_P{
        
    public:
    	virtual int operation(int a, int b) = 0;
    };
    
    class Product_Padd : public Product_P{
        
    public:
    	int operation(int a, int b){
        
    		return abs(a) + abs(b);
    	}
    };
    
    class Product_Pmul : public Product_P{
        
    public:
    	int operation(int a, int b){
        
    		return abs(a) * abs(b);
    		
    	}
    };
    
    class Product_F{
        
    public:
    	virtual int operation(int a, int b) = 0;
    };
    
    class Product_Fadd : public Product_F{
        
    public:
    	int operation(int a, int b){
        
    		return (-a) + (-b);
    	}
    };
    class Product_Fmul : public Product_F{
        
    public:
    	int operation(int a, int b){
        
    		return -(a*b);
    	}
    };
    
    class Factory{
        
    public:
    	virtual Product_P* Create_P() = 0;
    	virtual Product_F* Create_F() = 0;
    };
    
    
    class Factory_Add : public Factory{
        
    public:
    	  Product_Padd* Create_P(){
        
    		return new Product_Padd;
    	}
    	Product_Fadd*  Create_F(){
        
    		return new Product_Fadd;
    	}
    };
    
    class Factory_Mul : public Factory{
        
    public:
    	Product_Pmul* Create_P(){
        
    		return new Product_Pmul;
    	}
    	Product_Fmul* Create_F(){
        
    		return new Product_Fmul;
    	}
    };
    
    int main()
    {
        
    	Factory_Add *factory_add = new Factory_Add();
    	Factory_Mul *factory_mul = new Factory_Mul();
    	int p_add_result = factory_add->Create_P()->operation(1, 2);
    	int p_mul_result = factory_mul->Create_P()->operation(1, 2);
    	int f_add_result = factory_add->Create_F()->operation(1, 2);
    	int f_mul_result = factory_mul->Create_F()->operation(1, 2);
    	cout << "op_p_add：" << p_add_result << endl;
    	cout << "op_p_multiply：" << p_mul_result << endl;
    	cout << "op_f_add：" << f_add_result << endl;
    	cout << "op_f_multiply：" << f_mul_result << endl;
    	getchar();
    	return 0;
    }