本帖最后由 古月不傲 于 2020-11-14 13:38 编辑
简单工厂模式
[C++] 纯文本查看 复制代码 #include <iostream>
using namespace std;
// 简单工厂模式
namespace simple_factory_pattern {
enum laptop_types
{
LENOVO,
HUAWEI,
DELL
};
// 抽象一个笔记本电脑
class abstract_laptop
{
public:
virtual void create_laptap() = 0;
virtual ~abstract_laptop() {}
};
// 联想笔记本
class lenovo_laptop : public abstract_laptop
{
public:
virtual void create_laptap() override {
printf("生产了一台联想笔记本\n");
}
void own_someting() {}
};
// 华为笔记本
class huawei_laptop : public abstract_laptop
{
public:
virtual void create_laptap() override {
printf("生产了一台华为笔记本\n");
}
void own_someting() {}
};
// 戴尔笔记本
class dell_laptop : public abstract_laptop
{
public:
virtual void create_laptap() override {
printf("生产了一台戴尔笔记本\n");
}
void own_someting() {}
};
// 简单工厂模式
class factory
{
public:
abstract_laptop *get_laptop(laptop_types type) {
// 判断类型 返回实例对象
switch (type)
{
case LENOVO: {
return new lenovo_laptop;
break;
}
case HUAWEI: {
return new huawei_laptop;
break;
}
case DELL: {
return new dell_laptop;
break;
}
default: {
return nullptr;
break;
}
}
}
};
}
// 可以看出只需要new一个工厂 让工厂去处理 实力对象只需要接受就好
int main(void)
{
using namespace simple_factory_pattern;
// new一个工厂
factory *ft = new factory;
// 创建一台联想笔记本
abstract_laptop *l_laptop = ft->get_laptop(LENOVO);
l_laptop->create_laptap();
// 创建一台华为笔记本
abstract_laptop *h_laptop = ft->get_laptop(HUAWEI);
h_laptop->create_laptap();
// 创建一台戴尔笔记本
abstract_laptop *d_laptop = ft->get_laptop(DELL);
d_laptop->create_laptap();
delete d_laptop;
delete h_laptop;
delete l_laptop;
delete ft;
return 0;
}
// 总结
// 优点即缺点 当产品过多时，耦合性很差
// 优点:每当创建一个新的产品, 只需要在factory中处理逻辑即可
// 缺点:每当创建一个新的产品, 需要修改factory的代码
工厂方法模式
[C++] 纯文本查看 复制代码 #include <iostream>
using namespace std;
// 工厂方法模式
namespace factory_method_pattern {
// 抽象一个笔记本电脑
class abstract_laptop
{
public:
virtual void create_laptap() = 0;
virtual ~abstract_laptop() {}
};
// 联想笔记本
class lenovo_laptop : public abstract_laptop
{
public:
virtual void create_laptap() override {
printf("生产了一台联想笔记本\n");
}
void own_someting() {}
};
// 华为笔记本
class huawei_laptop : public abstract_laptop
{
public:
virtual void create_laptap() override {
printf("生产了一台华为笔记本\n");
}
void own_someting() {}
};
// 戴尔笔记本
class dell_laptop : public abstract_laptop
{
public:
virtual void create_laptap() override {
printf("生产了一台戴尔笔记本\n");
}
void own_someting() {}
};
// 抽象一个工厂
class abstract_factory
{
public:
virtual abstract_laptop *create_product() = 0;
virtual ~abstract_factory() {}
};
// 联想实例工厂
class lenovo_factory : public abstract_factory
{
virtual abstract_laptop *create_product() override {
return new lenovo_laptop;
}
void own_someting() {}
};
// 华为实例工厂
class huawei_factory : public abstract_factory
{
virtual abstract_laptop *create_product() override {
return new huawei_laptop;
}
void own_someting() {}
};
// 戴尔实例工厂
class dell_factory : public abstract_factory
{
virtual abstract_laptop *create_product() override {
return new dell_laptop;
}
void own_someting() {}
};
}
// 可以看出对比简单工厂模式，明显繁琐许多，需要new出一个实例工厂 但是有较好的松耦合
int main(void)
{
using namespace factory_method_pattern;
// new出三个实例工厂
abstract_factory *lenovo_ft = new lenovo_factory;
abstract_factory *huawei_ft = new huawei_factory;
abstract_factory *dell_ft = new dell_factory;
// new出联想笔记本
abstract_laptop *l_laptop = lenovo_ft->create_product();
l_laptop->create_laptap();
// new出华为笔记本
abstract_laptop *h_laptop = huawei_ft->create_product();
h_laptop->create_laptap();
// new出戴尔笔记本
abstract_laptop *d_laptop = dell_ft->create_product();
d_laptop->create_laptap();
delete d_laptop;
delete h_laptop;
delete l_laptop;
delete dell_ft;
delete huawei_ft;
delete lenovo_ft;
return 0;
}
// 总结
// 优点：具有较高的松耦合
// 缺点：比较繁琐，如果产品过多，代码量会非常庞大，每创建一个产品，需要创建一个实例工厂去处理
抽象工厂模式
[C++] 纯文本查看 复制代码 #include <iostream>
using namespace std;
// 抽象工厂模式
namespace abstract_factory_pattern {
// 抽象一个鼠标
class abstract_mouse
{
public:
virtual void create_mouse() = 0;
virtual ~abstract_mouse() {}
};
// 有线鼠标
class wired_mouse : public abstract_mouse
{
public:
virtual void create_mouse() override {
printf("生产了一个有线鼠标\n");
}
void own_someting() { }
};
// 无线鼠标
class wireless_mouse : public abstract_mouse
{
public:
virtual void create_mouse() override {
printf("生产了一个无线鼠标\n");
}
void own_someting() {}
};
// 抽象一个键盘
class abstract_keyboard
{
public:
virtual void create_keyboard() = 0;
virtual ~abstract_keyboard() {}
};
// 有线键盘
class wired_keyboard : public abstract_keyboard
{
public:
virtual void create_keyboard() override {
printf("生产了一个有线键盘\n");
}
void own_someting() {}
};
// 无线键盘
class wireless_keyword : public abstract_keyboard
{
public:
virtual void create_keyboard() override {
printf("生产了一个无线键盘\n");
}
void own_someting() {}
};
// 抽象一个工厂
class abstract_factory
{
public:
virtual abstract_mouse *create_mouse() = 0;
virtual abstract_keyboard *create_keyboard() = 0;
virtual ~abstract_factory() {}
};
// 有线工厂
class wired_factory : public abstract_factory
{
public:
virtual abstract_mouse *create_mouse() override {
return new wired_mouse;
}
virtual abstract_keyboard *create_keyboard() override {
return new wired_keyboard;
}
void own_someting() {}
};
// 无线工厂
class wireless_factory : public abstract_factory
{
public:
virtual abstract_mouse *create_mouse() override {
return new wireless_mouse;
}
virtual abstract_keyboard *create_keyboard() override {
return new wireless_keyword;
}
void own_someting() {}
};
}
// 可以看出对比工厂方法模式，只是把一系列类型的产品放在各自工厂中处理
int main(void)
{
using namespace abstract_factory_pattern;
// new出两个个实例工厂
abstract_factory *wired_ft = new wired_factory;
abstract_factory *wireless_ft = new wireless_factory;
// 有线鼠标
abstract_mouse *wired_m = wired_ft->create_mouse();
wired_m->create_mouse();
// 有线键盘
abstract_keyboard *wired_k = wired_ft->create_keyboard();
wired_k->create_keyboard();
// 无线鼠标
abstract_mouse *wireless_m = wireless_ft->create_mouse();
wireless_m->create_mouse();
// 无线键盘
abstract_keyboard *wireless_k = wireless_ft->create_keyboard();
wireless_k->create_keyboard();
delete wireless_k;
delete wireless_m;
delete wired_k;
delete wired_m;
delete wireless_ft;
delete wired_ft;
return 0;
}
// 总结
// 优点：可以把一系列产品放在工厂中处理，相对工厂方法模式会好很多
// 缺点：耦合性不是太好，比较繁琐，如果产品过多，代码量比较大，扩展比较困难
复习一遍设计模式 | 
[复制链接]
发表于 2020-11-14 11:15
