C++ 类生成管理器, 摆脱if/else
在开发中，经常遇到根据配置内容，生成对应的类, 例如:
name = "Product_A", 则生成产品A的类,
name = "Product_B", 则生成产品B的类,
产品A, 产品B都继承于同一个基类。
比较简单且常用的一个写法是这样的:
#include <iostream>
using namespace std;
class Base
{
public:
Base(){
//...};
};
};
class A : public Base
{
public:
A(){
//...};
};
};
class B : public Base
{
public:
B(){
//...};
};
};
Base* creator(std::string name)
{
if (name == "Product_A")
{
return new A();
}
else if (name == "Product_B")
{
return new B();
}
return nullptr;
}
这样写，虽然能满足需求，但是不够优雅，对于每一个产品大类(例如另外一种产品, 都继承于Base2)，都要写这样一坨if/else。
有没有更优雅的写法呢? 利用模板跟可变参数实现一个创建管理器:
#include <map>
using namespace std;
/* B : 基类
* T : B的派生类
* P : T的构造函数所需参数
*/
template <class B, class... P>
class CreateFctBase
{
public:
virtual ~CreateFctBase() = default;
virtual B* create(P... args) = 0;
};
template <class B, class T, class... P>
class CreateFct : public CreateFctBase<B, P...>
{
public:
virtual ~CreateFct() = default;
B* create(P... args)
{
return new T(args...);
}
};
template <class B, class... P>
class Factory
{
public:
Factory() = default;
virtual ~Factory()
{
for (auto& m : m_mapStr2Obj)
{
delete m.second;
}
m_mapStr2Obj.clear();
}
public:
void regist(std::string strName, CreateFctBase<B, P...>* creator)
{
m_mapStr2Obj[strName] = creator;
}
B* create(std::string strName, P... args)
{
auto it = m_mapStr2Obj.find(strName);
if (it != m_mapStr2Obj.end())
{
return it->second->create(args...);
}
return nullptr;
}
private:
std::map<std::string, CreateFctBase<B, P...>*> m_mapStr2Obj;
};
思路是, 通过模板的参数, 保存派生类的类型, 将字符串->类, 通过map<string, 模板类> 存储。
使用如下:
#include <iostream>
#include "creater.h"
class A
{
public:
virtual void print()
{
std::cout << a << std::endl;
}
public:
int a = 1;
};
class A1 : public A
{
virtual void print()
{
A::print();
std::cout << a1 << std::endl;
}
public:
int a1 = 11;
};
class B
{
public:
B(std::string str)
{
}
public:
virtual void print()
{
std::cout << a << std::endl;
}
public:
int a = 2;
};
class B1 : public B
{
public:
B1(std::string str) : B(str)
{
}
virtual void print()
{
B::print();
std::cout << a1 << std::endl;
}
public:
int a1 = 22;
};
class C
{
public:
C(int i, std::string str) : a(i), name(str)
{
}
public:
virtual void print()
{
std::cout << a << std::endl;
}
public:
int a = 0;
std::string name;
};
class C1 : public C
{
public:
C1(int i, std::string str) : C(i, str)
{
}
virtual void print()
{
std::cout << "this is C1:" << std::endl;
std::cout << "--- members:" << a << " " << a1 << name << std::endl;
}
public:
int a1 = 22;
};
class C2 : public C
{
public:
C2(int i, std::string str) : C(i, str)
{
}
virtual void print()
{
std::cout << "this is C2:" << std::endl;
std::cout << "--- members:" << a << " " << a12 << name << std::endl;
}
public:
int a12 = 222;
};
int main()
{
Factory<A> AFact;
AFact.regist("a1", new CreateFct<A, A1>());
auto pA = AFact.create("a1");
pA->print();
Factory<B, std::string> BFact;
BFact.regist("a1", new CreateFct<B, B1, std::string>());
auto pB = BFact.create("a1", "name");
pB->print();
Factory<C, int, std::string> CFact;
CFact.regist("c1", new CreateFct<C, C1, int, std::string>());
CFact.regist("c2", new CreateFct<C, C2, int, std::string>());
auto pC1 = CFact.create("c1", 1, "name_c1");
auto pC2 = CFact.create("c2", 1, "name_c2");
pC1->print();
pC2->print();
return 0;
}
这样基本摆脱了if/else的创建模式。但是像
CFact.regist("c1", new CreateFct<C, C1, int, std::string>());
CFact.regist("c2", new CreateFct<C, C2, int, std::string>());
这种，写法很冗余，且容易出错。继续优化一下, 使用类内置结构体, 共享类的模板参数。优化后如下:
#include <map>
using namespace std;
/* B : 基类
* T : B的派生类
* P : T的构造函数所需参数
*/
template <class B, class... P>
class CreateFctBase
{
public:
virtual ~CreateFctBase() = default;
virtual B* create(P... args) = 0;
};
template <class B, class T, class... P>
class CreateFct : public CreateFctBase<B, P...>
{
public:
virtual ~CreateFct() = default;
B* create(P... args)
{
return new T(args...);
}
};
template <class B, class... P>
class Factory
{
public:
Factory() = default;
virtual ~Factory()
{
for (auto& m : m_mapStr2Obj)
{
delete m.second;
}
m_mapStr2Obj.clear();
}
template <class T>
struct Registor
{
Registor(Factory* pFactory, std::string strName)
{
pFactory->regist(strName, new CreateFct<B, T, P...>());
}
};
public:
void regist(std::string strName, CreateFctBase<B, P...>* creator)
{
m_mapStr2Obj[strName] = creator;
}
B* create(std::string strName, P... args)
{
auto it = m_mapStr2Obj.find(strName);
if (it != m_mapStr2Obj.end())
{
return it->second->create(args...);
}
return nullptr;
}
private:
std::map<std::string, CreateFctBase<B, P...>*> m_mapStr2Obj;
};
相比一开始的实现, 只多了一个内置结构体：
template <class T>
struct Registor
{
Registor(Factory* pFactory, std::string strName)
{
pFactory->regist(strName, new CreateFct<B, T, P...>());
}
};
使用时, 会简单很多，如下:
#include <iostream>
#include "creater.h"
class ProductManager : public Factory<C, int, std::string>
{
public:
ProductManager() = default;
virtual ~ProductManager() = default;
public:
void regist()
{
Registor<C1>(this, "c1");
Registor<C2>(this, "c2");
// CFact.regist("c1", new CreateFct<C, C1, int, std::string>());
// CFact.regist("c2", new CreateFct<C, C2, int, std::string>());
}
};
int main()
{
ProductManager CFact;
CFact.regist();
auto pC1 = CFact.create("c1", 1, "name_c1");
auto pC2 = CFact.create("c2", 1, "name_c2");
pC1->print();
pC2->print();
return 0;
}
这样，如果再增加一个产品大类Base2, 则只需要写一个管理器 ProductManager2 继承于 Factory, 然后用Registor注册即可。
