Contenitori annidati con sottoclassi

Ho nidificato i contenitori A e B. Gli attributi sono lì per mostrare che le classi hanno altri membri. Una delle mie funzioni f prende un altro contenitore di tali contenitori (diciamo vector di nuovo).

ContainerA{
    int a;    
    std::vector<ContainerB> contc;    
}

ContainerB{
    int b;    
    std::vector<Element> contd;    
}

class Element{
}

void f (std::vector<ContainerA>& a){}

Ora un'altra funzione ha bisogno di un vettore di ContainerA potenziato con metodi aggiuntivi e aumenta gli elementi di tipo Element stesso. Voglio evitare di copiare il più possibile e davvero non voglio la funzione template f con tipo Element. Con il resto sono flessibile e posso prendere altre decisioni di progettazione.

Soluzione:

Contenitori modello A e B, sottoclasse A e Elemento, usa il puntatore su Elemento, per poter memorizzare LargerElement in esso:

class LargerElement: public Element{
   int e;
}
template <class T>
ContainerA{
    int a;    
    std::vector<ContainerB<T>> contc;    
}

template <class T>
ContainerB{
    int b;    
    std::vector<T*> contd;    
}
class LargerContainerA : public ContainerA<Element>{
    int d;
    public LargerContainerA (){
    // need to rewrite constructor to store
    // LargerElement* in Element* for all elements.
    }

}
void f (std::vector<ContainerA<Element>>& a){}
void g (std::vector<LargerContainerA>& la){}

L'utilizzo è simile a questo:

int main(){
   std::vector<ContainerA<Element>*> vec(100);
   for (auto& v: vec){
       v = new LargerContainerA(...); 
   }
   f(vec);

   std::vector<LargerContainerA*> vec2(vec.size());
   for (int i = 0; i < vec.size(); i++){
       vec2[i] = dynamic_cast<LargerContainerA*>(vec[i]);
   }
   g(lacont); 

   // free memory   
  ...

}

Ma i problemi rimanenti sono:

1. Tutto questo è brutto.
2. Funzione g quindi forzata a lavorare in termini di Element nelle sottofunzioni / classi chiamate e cast dinamico a Elemento Largo di tanto in tanto.