简单工厂模式
in 23种设计模式
实例化的活动不应该总是公开地进行，为了避免初始化总是造成耦合问题，将两者解耦
定义一个工厂类，其成员函数可以根据不同的参数创建并返回不同的类对象，调用者无需关注创建细节
简介
模式：简单工厂
英文：simple factory
定义：定义一个工厂类，其成员函数可以根据不同的参数创建并返回不同的类对象，调用者无需关注创建细节
意图：实例化的活动不应该总是公开地进行，为了避免初始化总是造成耦合问题，将两者解耦
设计准则
- 对修改关闭，对扩展开放：增加新功能不应该修改已经存在的代码，而应该通过增加新类或新成员函数
- 针对接口编程，不针对实现编程
- 依赖倒置原则：要依赖抽象，不要依赖具体类：不能让高层组件依赖低层组件，而且两者都应该依赖于抽象
- 封装变化：将容易变化的代码段限制在一个小范围内
代码
#include <iostream>
class Role {
public:
Role(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
virtual ~Role(){}
protected:
int m_life;
int m_magic;
int m_attack;
};
class R_A :public Role {
public:
R_A(int life, int magic, int attack) :Role(life, magic, attack)
{
std::cout << "创建A角色" << std::endl;
}
};
class R_B :public Role {
public:
R_B(int life, int magic, int attack) :Role(life, magic, attack)
{
std::cout << "创建B角色" << std::endl;
}
};
class R_C :public Role {
public:
R_C(int life, int magic, int attack) :Role(life, magic, attack)
{
std::cout << "创建C角色" << std::endl;
}
};
class RoleFactory
{
public:
Role* createRole(std::string roletype)
{
Role* p_Role = nullptr;
if(roletype=="A")
p_Role=new R_A(300, 400, 1000);
else if (roletype=="C")
p_Role = new R_C(1000, 400, 500);
else if (roletype == "B")
p_Role = new R_B(400, 400, 800);
return p_Role;
}
};
int main() {
RoleFactory rolefactory;
Role* p_role1 = rolefactory.createRole("A");
Role* p_role2 = rolefactory.createRole("C");
Role* p_role3 = rolefactory.createRole("B");
delete p_role1;
delete p_role2;
delete p_role3;
return 0;
}
由于创建角色与角色工厂本身无关，所以可以使用static方法，也就是是静态工厂方法模式
#include <iostream>
class Role {
public:
Role(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
virtual ~Role() {}
protected:
int m_life;
int m_magic;
int m_attack;
};
class R_A :public Role {
public:
R_A(int life, int magic, int attack) :Role(life, magic, attack)
{
std::cout << "创建A角色" << std::endl;
}
};
class R_B :public Role {
public:
R_B(int life, int magic, int attack) :Role(life, magic, attack)
{
std::cout << "创建B角色" << std::endl;
}
};
class R_C :public Role {
public:
R_C(int life, int magic, int attack) :Role(life, magic, attack)
{
std::cout << "创建C角色" << std::endl;
}
};
class RoleFactory
{
public:
static Role* createRole(std::string roletype)
{
Role* p_Role = nullptr;
if (roletype == "A")
p_Role = new R_A(300, 400, 1000);
else if (roletype == "C")
p_Role = new R_C(1000, 400, 500);
else if (roletype == "B")
p_Role = new R_B(400, 400, 800);
return p_Role;
}
};
int main() {
Role* p_role1 = RoleFactory::createRole("A");
Role* p_role2 = RoleFactory::createRole("C");
Role* p_role3 = RoleFactory::createRole("B");
delete p_role1;
delete p_role2;
delete p_role3;
return 0;
}
缺点
当引入新的子类时，需要修改createRole函数的源码，违背了开闭准则
