c++处理自引用的派生类

Question

所以假设我在 c++ 中有一个像这样的树类

class Node{
    void addChild(Node*);
    /*obvious stuff*/
    protected:
        Node* parent;
        vector<Node*> children
}

class specialNode : public Node{
    void addChild(specialNode*);
    /*obvious stuff*/
    /*special stuff*/
}

现在每当我访问specialTree中的子级时，我显然会得到Node*，而不是specialNode*。

但是这个特殊的Node*具有Node所没有的成员变量和函数。

我可以强制specialNode只将specialNode作为子节点，否则会在编译时中断， 但在访问子/父时我仍然得到 Node* ，并且每当我想使用特殊函数时我都必须强制转换它，即使在特殊Node函数中也是如此。

有什么聪明的或者更好的方法来解决这个问题吗？ 除了每次都直接铸造之外？

Answer 1

如果您的树中只需要 SpecialNode 对象（并且只想将所有通用树功能封装在 Node 中），则可以将 Node 设为所谓的之后

template <class N>
class Node : public N {
public:
  void addChild(Node<N>*);
protected:
  Node<N>* parent;
  vector<Node<N>*> children;
};

class SpecialNodeBase {
  // Here comes all "special" data/methods for your "special" tree
};

typedef Node<SpecialNodeBase> SpecialNode;

，您可以构造一个 SpecialNode 对象树，并使用 SpecialNodeBase 中的所有方法以及来自 Node 的其他树管理函数

Answer 2

因为子类中的 addChild 函数不是多态性，所以将其设为虚拟，但不允许跨基/子成员重载函数，因此我们必须更改子类中的 addChild 参数：

class Node{
    virtual void addChild(Node*);
    ...
}

class specialNode : public Node{
    virtual void addChild(Node*);
    ...
}

现在，它应该可以工作。

---

如果您想从子类（specialNode 类）访问 childeren 变量，则应该对其进行强制转换。例如：

specialNode* var = static_cast<specialNode*>(children[i]);

由于我们将 addChild 声明为虚函数，因此如果我们不确定 children[i] ，我们应该使用 dynamic_cast 而不是 static_cast code> 始终是 specialNode 类的实例，因此最好使用 dynamic_cast：

specialNode* var = dynamic_cast<specialNode*>(children[i]);
if(var != NULL)
{
    //...
}

Answer 3

如果我理解正确，“混合”类解决方案将不允许您从 SpecialNodeBaseClass 实现的函数中调用 addChild。

你实际上可以执行以下操作：

template <class recursiveT>
class Base {
public:

     Base(dataType data) { populate children with data; }

     void addChild() { something base class appropriate; }

protected:
     std::vector<recursiveT> children;
};




class Derived: public Base<Derived> {
public:
     /* note: the constructor here will actually call the 
        constuctor of the base class */
     Derived(dataType data) : Base<Derived>(data) {} 
     /* other special functions go here.  */
};

这可能看起来有点疯狂，但它在几个 GCC 版本上对我来说编译得很干净，所以我倾向于相信它并不是完全错误的。您现在应该能够从 Derived 内部调用 Base 的函数。

Answer 4

在某些时候，您肯定必须将 Node * 转换为 specialNode *，但您可以通过仅在一处执行此操作来使其干净且易于管理。您可以添加一个成员函数，例如 getParent 并在 specialNode 中重写它，如下所示：

class Node {
  ...
  virtual Node *getParent() {
    return parent;
  }
};

class specialNode : public Node {
  ...
  specialNode *getParent() {
    return dynamic_cast<specialNode *>(parent);
  }
};

当然，这是假设 specialNode 始终具有其他 specialNode 作为父/子节点。如果你混合使用Node和specialNode，这显然是行不通的。