Mi pare che questa soluzione non sia esente da rischi, almeno, da quanto letto in giro (v. ad esempio https://it.wikipedia.org/wiki/Dynamic_cast), anche se sinceramente non riesco a comprenderli, e soprattutto che appesantisca il codice.
Mi viene in mente che una alternativa allora possa essere la seguente, ma anche qui, data la scarsa esperienza, chiedo a voi se è logica come soluzione o se sarebbe "cattiva progettazione del codice".

codice:
class ClasseBase
{
  public:
    ClasseBase();
    virtual ~ClasseBase();
  //quanto altro necesario
}

class ClasseDerivata1:public ClasseBase
{
  public:
    ClasseDerivata1();
    ~ClasseDerivata1();
  //quanto altro necesario
}

class ClasseDerivata2:public ClasseBase
{
  public:
    ClasseDerivata2();
    ~ClasseDerivata2();
  //quanto altro necesario
}

class ClasseCornice
{
  public:
    ClasseCornice();
    ~ClasseCornice();

  private:
    ClasseBase* mBase;
    ClasseDerivata1* mDerivata1;
    ClasseDerivata2* mDerivata2;
    //metodi che gesticono la creazione/distruzione in base alle esigenze del codice, in modo che resti sempre e solo una sola istanza di uno degli oggetti gestiti
    //da ClasseCornice.

}
La cosa però potrebbe tornare utile anche se volessi fare un confronto tra mDerivata1 e mDerivata2, per esempio, corretto?
Mi spiego: mDerivata1 potrebbe gestire una serie di dati generati da una funzione, y=f(x).
mDerivata2, gestirebbe una cosa simile, ma la funzione, potrebbe cambiare, y=g(x), perchè legate, per quello che mi serve, a disposizioni di normativa che variano.
Nel caso volessi realizzare un grafico che plotti le due funzioni per avere un confronto, ClasseCornice dovrebbe permettermelo, coi dovuti "metodi".
Corretto?

Grazie.