Ciao a tutti!

Sto realizzando un programma in C++ per l'implementazione di un vocabolario mediante alberi Red Black. Nella traccia viene espressamente richiesto di fare uso dell'ereditarietà.

Ho strutturato il programma in questo modo:

codice:
    class nodo_BST
    {
    protected:
            string chiave;
            nodo_BST *sx;
            nodo_BST *dx;
            nodo_BST *padre;
     
    public:
            nodo_BST() // Costruttore
            {
                    chiave = "";
                    sx = NULL;
                    dx = NULL;
                    padre = NULL;
     
            }
           
            ~nodo_BST() // Distruttore
            {
            }
     
            string get_chiave()
            {
                    return chiave;
            }
           
            void set_chiave(string c)
            {
                    chiave = c;
            }
           
            nodo_BST* get_sx()
            {
                    return sx;
            }
           
            void set_sx(nodo_BST *sinistra)
            {
                    sx = sinistra;
            }
           
            nodo_BST* get_dx()
            {
                    return dx;
            }
           
            void set_dx(nodo_BST *destra)
            {
                    dx = destra;
            }
           
            nodo_BST* get_padre()
            {
                    return padre;
            }
           
            void set_padre(nodo_BST *p)
            {
                    padre = p;
            }
    };
     
    class nodo_RB : public nodo_BST
    {
    private:
            colore c;
     
    public:
            nodo_RB():nodo_BST() // invoco il costruttore della superclasse
            {
                    c = nero;
            }
           
            ~nodo_RB()
            {
     
            }
     
            colore get_color ()
            {
                    return c;
            }
     
     
            void set_color (colore colore_in)
            {
     
                    c = colore_in;
            }
    };
Come potete vedere, la classe nodo_RB è una sottoclasse di nodo_BST. Il problema è il seguente: mettiamo caso che, per esempio, dopo aver creato un oggetto della classe nodo_RB, debba necessariamente invocare il metodo get_sx per conoscere il figlio sinistro del nodo corrente. Il compilatore mi da errore, dicendo che il metodo della superclasse restituisce un nodo_BST.

Come risolvere il problema?

Ho letto che può essere utilizzato il downcasting (magari quello dinamico che controlla pure se il tipo "castato" è effettivamente diventato quello richiesto) ma mi chiedevo se fosse possibile prendere un'altra strada.

Grazie in anticipo per le risposte!