我如何控制繼承代碼的不同部分

Question

嗨，我有一個關於如何訪問繼承代碼部分的問題。

說我有這個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?
}
};

Answer 1

您可以執行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> {
}

Answer 2

即使您可能不喜歡，最重要的是不要一開始就丟棄類型信息。

通用“對象”的集合是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通過拋出異常來指示失敗，因為沒有空引用。

Answer 3

一種簡單（顯而易見）的解決方案是使用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();
}