[英]How can i accsess different parts of my inherited code
嗨,我有一个关于如何访问继承代码部分的问题。
说我有这个WorldObject是许多其他对象的基类。 然后,我有一个Chest类,它继承自WorldObject和抽象类OpenAble,并带有一些方法,如打开和解锁。
在我的主要语言中,我有一个WorldObjects向量,可以使用for循环进行迭代。 现在要问的问题是,如何检查worldobject是否也是OpenAble的,以及如何访问OpenAble中的方法。
class WorldObject
{
... //implementation
};
class OpenAble
{
public:
OpenAble(){}
virtual ~OpenAble(){}
virtual void Open() = 0;
virtual void Unlock(int k) = 0;
};
class Chest : public WorldObject, public OpenAble
{
... //implementation
};
main()
{
std::vector<WorldObject> objVector; //vector with several Worldobjects
for (int i =0; i < objVector.Size(); i++)
{
//check if a WorldObject is also of openable
//Do som actions like, open or unlock
//How?
}
};
您可以执行dynamic_cast<OpenAble>
。 如果类型错误,这将引发错误,但是由于对象很可能是错误的类型,所以这是相对昂贵的。
try{
OpenAble& opener = dynamic_cast<OpenAble&>(worldObj);
} catch (std::bad_cast& ex){
//not openable
}
顺便说一句:正如下面的注释所指出的,如果您在容器中使用指向基类的指针而不是引用,则可以(并且应该)使用dynamic_cast的指针版本,如果您的对象使用该指针版本,则将返回null不是OpenAble。 在您的情况下进行检查比抛出和捕获异常要有效得多。
我会建议一种完全不同的方法。 为您的基类注入“ OpenPolicy”。
例如
class CanOpenPolicy {
public:
boolean canOpen(){ return true; };
boolean canClose(){ return true; };
boolean isOpen(){ return openState; };
void open(){ openState = OPEN; };
void close(){ openState = CLOSED; };
}
class NoOpenPolicy {
public:
boolean canOpen(){ return false; };
boolean canClose(){ return false; };
boolean isOpen(){ return CLOSED; };
void open(){ throw IllegalWorldObjectAction("OpenPolicy disallows operation"); };
void close(){ throw IllegalWorldObjectAction("OpenPolicy disallows operation"); };
}
//injection via template (no need for base "OpenPolicy" class, maybe some
// obscure error codes at compile though)
// Implicit interface based on how you use the injected policy.
template<OpenPol>
class WorldObject {
private:
// CTOR part of the injected contract so you are not tied to knowing how to
// build the policy. This is a key benefit over interface based injection.
OpenPol openPol;
...
public:
...
void open(){
if(openPol.canOpen()){
openPol.open();
}
}
...
}
这未经测试或任何东西。 只是为了说明这个想法。 您可以为不同的可能操作添加多个策略,最好的事情是您不需要太多的层次结构。
要使用它,只需执行以下操作:
std::unique_ptr<WorldObject>( new Chest() );
std::unique_ptr<WorldObject>( new Banana() );
std::unique_ptr<WorldObject>( new Chair() );
哪里:
class Chest : public WorldObject<CanOpenPolicy> {
// Very little implementation in here.
// Most of it is handled in the base class and the injected policies :)
}
class Banana: public WorldObject<CanOpenPolicy> {
}
class Chair : public WorldObject<NoOpenPolicy> {
}
即使您可能不喜欢,最重要的是不要一开始就丢弃类型信息。
通用“对象”的集合是Java主义,不是用C ++来做事。
也就是说,如果静态已知的类是多态的(具有至少一个虚拟成员函数),则可以使用dynamic_cast
或typeid
。 此功能称为RTTI ,是运行时类型信息的简称。 对于某些编译器,您必须使用特殊选项来启用RTTI。
习惯用法dynamic_cast
:
WorldObject* p = ...;
if( auto p_openable = dynamic_cast<OpenAble*>( p ) )
{
// use p_openable
}
请注意,指向动态指针的dynamic_cast
通过返回空指针来指示失败,而指向动态指针的dynamic_cast
通过抛出异常来指示失败,因为没有空引用。
一种简单(显而易见)的解决方案是使用dynamic_cast并将您的对象转换为OpenAble
。
“简单(显而易见)的解决方案”的问题在于,通常,dynamic_cast的使用表明您的类层次结构缺乏灵活性,这是设计问题的征兆。
我将提供OpenAble接口作为通过句柄公开的一组行为:
class OpenAble { /* ... */ };
class WorldObject
{
//implementation
virtual OpenAble* GetOpener() { return nullptr; }
};
class Chest: public WorldObject {
struct ChestOpener: public OpenAble {
Chest *c;
virtual void Open() {
// do stuff with c
}
};
std::unique_ptr<OpenAble> chest_opener;
public:
virtual OpenAble* GetOpener() {
if(!chest_opener) {
chest_opener = new ChestOpener{ this };
}
return chest_opener.get();
}
};
客户代码:
std::vector<WorldObject> objVector; //vector with several Worldobjects
for(auto &obj: objVector)
{
if(auto openerHandle = obj.GetOpener())
openerHandle->Open();
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.