我可以限制多态性的行为吗？

Question

所以我正在尝试实现二叉搜索树和 avl 树。这些类中的每一个都使用不同但相似类型的节点。节点的类如下所示：

class node
{
protected:
    int key;
    node* parent, * left, * right;
public:
    node(int key, node* parent = nullptr) :key(key), parent(parent), left(nullptr), right(nullptr) {}
    ~node() {}
};

---

class avl_node : public node
{
private:
    int height;
public:
    avl_node(int key, int height, avl_node* parent = nullptr) :node(key, parent), height(height) {}
    ~avl_node() {}
};

这主要是有效的。任何node 可以与任何其他node 建立联系，任何avl_node 可以与任何其他avl_node 建立联系。我想到的问题是，由于多态性，node 在技术上可能有一个或多个父级或子级avl_node，我不希望这种情况发生。虽然我可以通过小心来避免这种情况，但我根本不希望它成为可能。有没有办法？
p.s.我想保持类相关

Answer 1

如果足够，您可以显式删除将采用 avl_node* 的构造函数版本

class node
{
protected:
    int key;
    node* parent, * left, * right;
public:
    node(int key, node* parent = nullptr) :key(key), parent(parent), left(nullptr), right(nullptr) {}
    node(int, avl_node*) = delete;
    ~node() {}
};

当然，这个解决方案并非万无一失。如果您将 avl_node 隐藏在 node 指针后面，编译器将无法分辨（并且由于多态性主要是动态的，因此只有在尝试直接分配指针的特定情况下才会受到保护）

这会编译。

avl_node myavl;
node n(0, static_cast<node*>(&myavl));

您可以尝试在 node 构造函数中进行动态转换，以判断它是否是正在传递的 avl_node（您的节点需要一个 vtable），但这将使得无法从avl_node构造函数。

另一种选择是为子类创建一个单独的构造函数

class node
{
protected:
    int key;
    node* parent, * left, * right;
    node(int key, avl_node* parent) : key(key), parent(parent), left(nullptr), right(nullptr) {}
public:
    node(int key, node* parent = nullptr) :key(key), parent(parent), left(nullptr), right(nullptr) { /* do something to not allow avl_node* to be passed */ }
    ~node() {}
};

Answer 2

您可以摆脱多态性并使用类模板作为基类模板和依赖于模板参数的成员。

例子：

template<typename T>
class node
{
protected:
    int key;
    node* parent, * left, * right;  // Note: these are actually 'node<T>'.
public:
    node(int key, node* parent = nullptr) 
        : key(key), parent(parent), left(nullptr), right(nullptr) {}
    void set_parent(node* p) { parent = p; }
};

class avl_node : public node<avl_node>
{
private:
    int height;
public:
    avl_node(int key, int height, avl_node* parent = nullptr) 
        : node(key, parent), height(height) {}
};

class silly_node : public node<silly_node>
{
public:
    silly_node() : node(0) {} 
};

int main()
{
    // Fine
    avl_node an(0, 1);
    // Fine
    avl_node bn(0, 1, &an);
    // Also fine
    bn.set_parent(&an);
    // Fine
    silly_node sn;
    // Compilation error
    avl_node cn(0, 1, &sn);
    // Also compilation error
    bn.set_parent(&sn);
}