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

Question

So i'm trying to implement a binary search tree and avl tree. Each of these classes using different but similar types of nodes. The classes for nodes look like this:

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() {}
};

This mostly works. Any node can have connexions with any other node , and any avl_node with any other avl_node . The issue that I think of is that a node could technically have a parent or children avl_node because of polymorphism, and I wouldn't want that to happen. Although I can avoid that by being careful, i wouldn't want it to be possible at all. Is there a way?
ps I want to keep the classes related

Answer 1

If it's enough, you could explicitly delete the version of constructor that would take an 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() {}
};

Of course, this solution is not foolproof. If you brought an avl_node hidden behind a node pointer, the compiler wouldn't be able to tell (and since polymorphism is mainly dynamic, you would only be protected in this specific case where you attempt to assign the pointer directly)

This would compile.

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

You could try dynamic-casting in the node constructor to tell if it's an avl_node being passed (your nodes would need a vtable for that), but that would make it impossible to call the constructor like that from the avl_node constructor.

Another option would be making a separate constructor intended specifically for the subclass

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

You can get rid of polymorphism and avoid code duplication by using a class template for the base, and members that depend on the template argument.

Example:

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);
}