节点层次结构和继承

Question

我制作了一个场景图层次结构，其中每个节点都有一个父节点，也可能有子节点。我创建了这个 BaseNode 类

class BaseNode
{
public:
    BaseNode(const char *nodeName, BaseNode *parent);
    ~BaseNode();

    BaseNode* addChildSceneNode(const char *name);
    void deleteChildSceneNode(const char *name);
    void deleteAllChildSceneNodes();

    BaseNode* findFirstSceneNode(const char *name);
    BaseNode* getChildSceneNode(const char *name);
    BaseNode* getChildSceneNode(unsigned int index);

    void setName(const char *name);
    void setTranformation(const glm::mat4 &transformation);

    unsigned int getNumChildren() const { return _children.size(); }
    const char *name() const { return _name.c_str(); }
    BaseNode* parent() const { return _parent; }
    const glm::mat4& transformation() const { return _transformation; }
    const glm::mat4& toRootTransformation() const { return _toRoot; }

protected:
    std::string _name;

    glm::mat4 _transformation;
    glm::mat4 _toRoot;

    BaseNode *_parent;
    std::vector<BaseNode*> _children;
};

我有这个继承自 BaseNode 的 SceneNode 类

class SceneNode : public BaseNode
{
public:
    SceneNode(const char *nodeName, SceneNode *parent);
    ~SceneNode();

    void attachRenderMeshData(RenderMeshData *renderMeshData);

    const std::vector<RenderMeshData*>* renderMeshDatas() { return &_meshDatas; }

private:
    std::vector<RenderMeshData*> _meshDatas;
};

现在我的问题是关于包含 BaseNode* 参数的所有成员函数。

目前，在处理 SceneNode 对象时，我必须将 BaseNode* 显式转换为 SceneNode*，如下所示

SceneNode *mySceneNode = new SceneNode("root", nullptr);
mySceneNode->addChildSceneNode("my child");
SceneNode *child = reinterpret_cast<SceneNode*>(mySceneNode->getChildSceneNode("my child")); //i thought this should be dynamic_cast but the compiler throws an error.. weird

我的目标是拥有“多种类型”的 BaseNode，因此我不必每次都重写其父/子功能。

知道如何才能做得更好吗？

Answer 1

为什么不为您的BaseNode 课程使用模板？

这样你就可以在不同类型的 BaseNode 之间有共同的代码。

例如，要创建SceneNode，您可以使用BaseNode<SceneNode>。

An example on C++ class templates.

---

如果SceneNode 继承BaseNode，您可以简单地将SceneNode 分配给BaseNode* 类型而无需强制转换。您可能还需要调用基类的构造函数。

class SceneNode : public BaseNode {
public:
    SceneNode() : BaseNode("foo") {}
};

因此，如果您调用 s = new SceneNode，您应该能够将 s 分配给 BaseNode* 的集合而无需强制转换。