Récurrence de modèle C++ - comment résoudre?

Question

Je suis à nouveau coincé avec des modèles. Disons, je veux mettre en œuvre un système guicell. chaque guicell peut contenir un certain nombre de guicellules. jusqu'à présent, donc la structure de l'arbre. en std-C++ j'irais pour sthg. comme:

template <typename T> 
class tree 
{ 
public: 

    void add (T *o)  { _m_children.push_back (o); } 
    void remove (T *o) { ... }; 

    list<T*> _m_children; 
}; 

class _cell : public tree<_cell> 
{ 
public: 
    _cell()   { x = 0; y =0; } 
    long    x,y; 
}; 

Mais maintenant je veux aller plus loin, et rendre les cellules référencables si le codeur le souhaite. donc j'implémente fondamentalement une refTree - classe à cette fin qui prend aussi juste des pointeurs (_cell *) en entrée.

template <typename T> 
class refTree 
{ 
public: 
    void add (T *o)  { _ref<T> r = o; _m_children.push_back (r); } 
    void remove (T *o)  { ... } 

    list<_ref<T> > _m_children; 
}; 

Aussi, cela fonctionne encore très bien. en utilisant

class _cell : public refTree<_cell> 
{ 
    : 
}; 

aucun changement à l'utilisateur de code, mais tout ajouté _cell * sont maintenant référencées avant de les ajouter à l'arbre. Bon, mais maintenant je veux pouvoir choisir sur _cell - level quelle implémentation arborescente utiliser. Cela signifie donc que je dois faire de la _cell - class une classe de template qui prend une classe de template en paramètre (le template d 'arbre choisi).

template <template <typename> class __TyTree = tree> 
class Cell : public __TyTree <Cell>  // cannot work - no question, Cell expects input 
{ 
}; 

Et ici nous avons eu le problème récurrent - ofcourse le compilateur ne peut pas résoudre, parce que la cellule est en attente d'un arbre -. Paramètre qui attend un paramètre de type simple (qui devrait être un COF cellulaire est en attente un arbre - paramètre qui attend un simple ....).

Vous obtenez l'image - quelle est une bonne solution à ce genre de problème?

Answer 1

Il n'y a pas de récursivité. L'argument du modèle pour Cell est __TyTree, et non __TyTree<Cell>.

template <template <typename> class __TyTree = tree> 
class Cell : public __TyTree <Cell<__TyTree> > 
{ 
}; 

int main() 
{ 
    Cell   mycell0; // error 
    Cell<>  mycell1; // ok. tree is used 
    Cell<tree> mycell2; 
    Cell<refTree> mycell3; 
} 

P.S. Vous ne devez pas utiliser deux traits de soulignement principaux dans __TyTree car il est réservé à des fins d'implémentation par C++ Standard.

Answer 2

Vous avez deux problèmes distincts: le contenu d'une cellule et la manière dont les cellules sont connectées entre elles. Vous devez utiliser deux structures de données distinctes pour cela. En d'autres termes, le bon lien à rompre est l'héritage de la cellule de l'arbre. La petite quantité de mémoire que vous enregistrez ne vaut pas la peine - abandonnez l'approche "intrusive". La cellule ne doit pas être consciente de la façon dont l'arbre le tient.