我想做什么:我从XML文件加载数据(这很好)。 XML告诉程序创建类实例(来自特定的不同类,如Car
或Plane
),然后它们将存在于程序中。这些类实例对象是总体Object
基类的子类。
XML文件以数字的形式存储需要创建的对象类型,程序将从中确定要创建的对象类。
我可以使用switch
语句并枚举所有类型的对象,但在添加大量对象实例时,这会对性能造成极大的负担。所以相反,我想要从char[2]
到所需类的映射。 (注意:类类本身,不是类的实例。)
例如,如果XML属性显示'type=0x01'
,则会生成类Car
中的对象,而如果'type=0x02
'则会生成Plane
个对象制作。 (两者都是Object
)
通过这种方式,我想使用常量映射来完成这项工作。我想写点像
map<char[2],class> ObjectsList = {
{0x01,Car},
{0x02,Plane}
//etc, etc.
}
...
// while loading data from xml file on which objects need to get created,
// an object-tag gives data from 'type' attribute, and the program stores
// it in 'char[2] type';
char[2] type = getattributestufffromxml("type");
ObjectsList[type] newObject = memoryallocator.allocate(sizeof(ObjectsList[type]);
newObject.Init(); //inherited function from Object
这样做的想法是创建一种更快的方法而不是坚持使用switch语句,这在创建数百个对象时非常糟糕。
从上面的内容到有效的C ++,我需要做些什么?我不知道如何在地图中存储类类型。 (我得到编译器错误,例如'参数2/4无效')
答案 0 :(得分:3)
我不知道如何在地图中存储类类型。 (我经常得到'参数2/4无效')
好吧,char[2]
数组不能用作std::map::key_type
,因为它不符合Compare
concept的必要约束。
从初始化列表中看,您希望uint8_t
为关键值。
此外,您无法将类型存储为地图中的值。
你是否应该使用函数指针构造函数that's not possible,因为构造函数和析构函数是特殊的beasts(没有返回类型甚至不void
),你不能用它们引用它们一个函数指针。
我认为您实际需要的是std::map
存储与enum
对应的工厂函数,如:
enum class VehicleTypes : uint8_t {
CarType = 0x01 ,
PlaneType = 0x02 ,
};
struct Vehicle {
virtual ~Vehicle() {}
virtual void Init() = 0;
};
typedef std::function<Vehicle*()> CreateVehicleFn;
class Car : public Vehicle {
public:
virtual void Init() {
// do anything necessary to init a Car
}
};
class Plane : public Vehicle {
public:
virtual void Init() {
// do anything necessary to init a Plane
};
std::map<VehicleTypes,CreateVehicleFn> CreatorFnList =
{ { VehicleTypes::CarType, []() { return new Car(); } } ,
{ VehicleTypes::PlaneType, []() { return new Plane(); } }
};
后一个映射初始化列表的编写代码不比您在(伪)代码示例中提供的代码多 如果你想摆脱锅炉板的东西,并认为值得模糊你的代码,你仍然可以使用宏:
#define Create(classtype) []() { return new classtype(); }
std::map<VehicleTypes,CreateVehicleFn> CreatorFnList =
{ { VehicleTypes::CarType, Create(Car) } ,
{ VehicleTypes::PlaneType, Create(Plane) }
};
您可以稍后使用它来创建新实例,具体取决于关键参数:
Plane* plane = dynamic_cast<Plane*>(CreateVehicleFn[VehicleTypes::PlaneType]());
if(plane) {
plane->Init();
}
提供明确的所有权语义甚至考虑使用std::unique_ptr<Vehicle>
来传递从工厂到客户端的新实例:
typedef std::function<std::unique_ptr<Vehicle>()> CreateVehicleFn;
std::map<VehicleTypes,CreateVehicleFn> CreatorFnList =
{ { VehicleTypes::CarType, []() { return make_unique<Car>(); } } ,
{ VehicleTypes::PlaneType, []() { return make_unique<Plane>(); } }
};
使用语法与我的第一个样本大致相同:
std::unique_ptr<Plane> plane = CreateVehicleFn[VehicleTypes::PlaneType]();
if(plane.get()) {
plane->Init();
}
答案 1 :(得分:1)
在C ++中,类是(编译类型)定义,而不是(运行时)数据对象。所以你不能存储课程。
但是,您可以声明Factory类型,并存储工厂的实例。
例如:
class Factory
{
virtual std::unique_ptr<Object> createInstance(std::string description);
}
class CarFactory : public Factory
{
std::unique_ptr<Object> createInstance(std::string description) override;
}
class PlaneFactory : public Factory
{
std::unique_ptr<Object> createInstance(std::string description) override;
}
然后我们存储工厂:
std::map<const char[2],Factory*> factories = {
{"00", new CarFactory},
{"01", new PlaneFactory},
//...
}
您可以创建一个通用工厂:
template<typename T>
class VehicleFactory : public Factory
{
std::unique_ptr<Object> createInstance(std::string description) override
{ return std::make_unique<T>(description); }
}
std::map<int,Factory*> factories = {
{"00", new VehicleFactory<Car>},
{"01", new VehicleFactory<Plane>},
//...
}
一旦我们有工厂,我们就可以使用它:
std::unique_ptr<Object> createVehicle(const char type[2], std::string description)
{
// error handling is an exercise for the reader
return factories[type]->createInstance(description);
}