我如何访问继承代码的不同部分

How can i accsess different parts of my inherited code

本文关键字：代码 同部 继承 何访问 访问      更新时间：2023-10-16

您好，我有一个关于如何访问部分继承代码的问题。

假设我有这个WorldObject，它是许多其他对象的基类。然后我有一个类Chest，从WorldObject继承，也从抽象类OpenAble，有一些方法，如打开和解锁。

在我的主我有一个向量的世界对象，我迭代通过一个for循环。现在的问题，我怎么能检查如果一个世界对象也是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
}

BTW:正如在下面的评论中指出的那样，如果您使用指向容器中的基类的指针而不是引用，那么您可以(并且应该)使用dynamic_cast的指针版本，该版本将在您的对象不是OpenAble的情况下返回null。在你的情况下，检查这一点比抛出和捕获异常要有效得多。

我建议采用一种完全不同的方法。用"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指向指针的操作通过返回nullpointer来表示失败，而dynamic_cast指向引用的操作通过抛出异常来表示失败，因为没有nullreferences。

简单(明显)的解决方案是使用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();
}
相关文章：