基类到派生类类型转换

Question

我有一个基类：

class RedBlackTreeNode
{
// Interface is the same as the implementation
public:
    RedBlackTreeNode* left;
    RedBlackTreeNode* right;
    RedBlackTreeNode* parent;
    Color color;
    TreeNodeData* data;

    RedBlackTreeNode():
        left(0),
        right(0),
        parent(0),
        color(Black),
        data(0)
    {
    }
    // This method is to allow dynamic_cast
    virtual void foo()
    {
    }
};

以及从它派生的一个：

class IndIntRBNode : public RedBlackTreeNode
{
public:
    IndIntRBNode* left;
    IndIntRBNode* right;
    IndIntRBNode* parent;
    IndexedInteger* data;
    IndIntRBNode():
        RedBlackTreeNode(),
        left(0),
        right(0),
        parent(0),
        color(Black),
        data(0)
    {
    }
};

root() 和 rootHolder 定义在 RedBlackTree 类中：

class RedBlackTree 
{
public:
    RedBlackTreeNode rootHolder;
    RedBlackTreeNode* root()
    {
        return rootHolder.left;
    }
    ...
}

然后我尝试进行类型转换：

IndIntRBNode *x, *y, *z;

z = dynamic_cast<IndIntRBNode*>(root());

而“z”只是变成了一个零指针，这意味着类型转换失败了。 那么它有什么问题，我该如何修复它以将“z”作为指向 IndIntRBNode 的指针进行引用？

补充：rootHolder.left 的初始化是这样的：

    int n = atoi(line + i);

    tree.clear();
    int j = 0;
    if (n > 100)
    {
        n = 100;        // Maximum 100 nodes
    }
    while (j < n)
    {
        IndexedInteger num(j,j + 10);
        RedBlackTreeNode* node;
        int c = tree.search(&num, tree.root(), &node);
        if (c != 0)
        { // if value is not in the tree
            IndexedInteger* v = new IndexedInteger(num);
            tree.insert(node, v, c);
            ++j;
        }
    }

换句话说，它是在“while”的第一次迭代时通过“insert”方法以这种方式初始化的：

void RedBlackTree::insert(
    RedBlackTreeNode* parentNode,
    TreeNodeData* v,
    // If it's negative, then add as the left son, else as the right
    int compare
)
{
    assert(parentNode != 0 && compare != 0);
    RedBlackTreeNode* x = new RedBlackTreeNode;
    x->data = v;
    x->parent = parentNode;
    // If it's root
    if (parentNode == &rootHolder)
    {
        // Then it must be black
        x->color = Black;
    }
    else
    {
        // Leaf must be red
        x->color = Red;
    }
    if (compare < 0)
    {
        // Insert the node as the left son
        assert(parentNode->left == NULL);
        parentNode->left = x;
    }
    else
    {
        // Insert the node as the right son
        assert(parentNode != &rootHolder && parentNode->right == NULL);
        parentNode->right = x;
    }

    ++numNodes;

    if (x != root())
    {
        rebalanceAfterInsert(x);
    }
}

实际上是问题所在：“插入”动态创建了 RedBlackTreeNode，因此它不可能是 IndIntRBNode。 我真的把它初始化错了，但是我怎么能派生基类而不是从头开始编写它的整个实现来改变类型呢？ 我真的必须重写派生类中的所有“类型相关”方法吗？这似乎很愚蠢，我认为应该有另一种方式 - 类派生和类型转换的东西，不是吗？

Answer 1

你确定 RedBlackTree::rootHolder.left 已经初始化了吗？

我认为您在某个地方初始化了 IndIntRBNode::left，但是当您访问 RedBlackTree::rootHolder.left 时，您访问的是 RedBlackTreeNode::left，这不是同一个字段。

Answer 2

等等 .. 你有一个派生类，其类型与基类同名。那是怎么编译的？

rootHolder.left 是如何初始化的？因为如果 dynamic_cast 失败，那么它不是 IndIntRBNode 类型。

基本上你没有提供足够的代码来证明你做错了什么，但你做错了什么。

Answer 3

如果我正确阅读了您的代码，那么您根本没有将 rootHolder.left 设置为 IndIntRBNode 指针，而是一个普通的 RedBlackTreeNode。

另外，你不需要为多态性编造一个无用的虚函数；只需将析构函数声明为virtual 并提供一个空实现。您对多态性的使用也不是很好，因为IndIntRBNode 成员将隐藏RedBlackTreeNode 成员，因此它们可能指向不同的事物，具体取决于您是通过IndIntRBNode 指针/引用还是@ 访问它们987654328@ 指针/引用。

Answer 4

无论您的示例代码可能存在或不存在任何其他缺陷，它的编写方式似乎都误解了继承和强制转换的工作原理。我建议您选择一本 C++ 书籍并阅读它。

特别是，您应该知道每个对象都是一种且只有一种类型。一旦创建了一个对象，它就永远不会改变类型。转换指针不会将对象从一种类型转换为另一种类型，也不会创建新类型的新对象。转换允许您根据指定的类类型使用现有对象，但前提是该对象已经属于该类，或者是从该类派生的类。

在你目前有这条线的地方：

z = dynamic_cast<IndIntRBNode*>(root());

试试这个：

RedBlackTreeNode* other_z = root();

如果other_z不为NULL，那么root()就不是IndIntRBNode，世界上所有的dynamic_casting都不会把它合二为一。