版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/chaipp0607/article/details/100107319
工厂模式分为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;
}