Template et abstraction

Bonjour à tous,

Je n'arrive pas à m'en sortir dans un cas, avec des templates, que j'aimerai avoir des pointeurs super générique dessus.

Je m'explique :aie:
Voici mon code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

template <typename GameBoard> class Controler : public Listener<Move<typename GameBoard::Coords> > { typedef typename GameBoard::Coords Coords;   private:   protected: int m_colorControlled; /*!< Color associated to this controler */   public: /*! \brief Default constructor      *  Will define an invalid color making this controller basically invalid      */ Controler():m_colorControlled(-1) {} // Put an invalid color   // virtual ~Controler() = 0; /*! \brief Gets the move that the controler wants to play      *  This function is generally waiting for the move from the controler.      *  \return      */ virtual Move<Coords> getMove() =0;   /*! \brief Defines the color used by the controler      *  \param color      */ virtual void setColorControled(int color) { m_colorControlled = color; } };

---

J'aimerai pouvoir faire un pointeur de Controler. donc générique au possible. Mais comme ma classe est template, la généricité est stoppée nette une fois un type spécifié (Controler<Type>). Ok, c'est normal.

La solution en général, c'est de faire une classe abstraite au dessus. Soit, mais en fait, je ne peux pas faire mieux dans ce sens là (j'hérite déjà cette classe).

Mon problème, c'est que je veux vraiment une fonction virtuelle pure getMove() et que en plus celle-ci me retourne le type Coord qui est sous jacent au plateau.

Est ce qu'il existe une solution et quelle serait-elle ?

(Note, le Listener peut être complêtement éjecté, donc ne nous en préoccupons pas)

En écrivant ce message, j'ai pensé que peut être, le type de retour getMove() et donc la fonction, ne devra être spécifié que dans les classe héritante, mais je souhaite vraiment avoir la fonction en virtuelle pure.
Sinon, peut être passer la fonction en fonction template (donc, que le template soit spécifier à l'appel et non à la création de la classe). Je suis pas sur que cela puisse marcher et surtout que le compilateur ne m'enguirlande pas à faire des fonction templates virtuelle pure :aie: (je vais tester)
EDIT : Bah oui, un template ne peut pas être virtuel ... :aie:

Bonjour,

La description du problème technique me laisse à penser que tu n'as peut-être pas définie assez clairement les points de variation de ton design en particulier le moment de leur détermination (compilation/exécution pour ton cas).

Pourquoi as-tu besoin d'un pointeur sur un Controler<T> dont tu ne connais pas le T ? Dit autrement quand est déterminé le GameBoard utilisé ?

Sinon de manière plus générique la solution typique est un Variant couplé à un Visitor. Cependant ta volonté de connaitre le Coords pour le type de retour va être un problème.

NB: Non, fonction template virtuelle ça n'existe pas.

En fait, les controleurs ne sont utilisé que dans une classe Game. Cette classe, je veux aussi la rendre abstraite (AbstractGame), qui aura une fonction addControler et le controler devra donc être un pointeur.

Le but d'avoir un abstract game était de faire un jeu qui, après la demande de l'utilisateur, soit un jeu d'échec, ou un jeu de dame, ou un jeu autre :P

Donc, oui, à un moment j'ai un conflit dans le fait de savoir si c'est compilation-time ou execution-time. Mais en même temps, je me dis que cela pourrait fonctionner :aie:

Tu codes pour faire un programme ou une bibliothèque ? "l'utilisateur" c'est l'utilisateur final ou l'utilisateur de ta bibliothèque ?

Faire un passage détermination compile time / détermination runtime, ca se fait (typiquement via une factory sur un type variant). Cependant devoir en abuser est un signe d'un problème dans les choix du design.

Est-ce que le type Gameboard est connue au sein d'un classe concrète GameA ? Si non, où/quand/par qui est déterminé ce type ?

Utilisateur finale (le joueur).
J'avais décidé de faire une fabrique, qui fabriquerai les game, afin de les ressortir en AbstractGame et de les utiliser. Mais à cause de ce controler qui est finalement dépendant du plateau (quoi que ... je dis peut être une bétise).
J'essaie d'éviter les abus et le coup du variant ne me semble pas du tout une solution cette fois.

Bonsoir,

et si tu passais en paramètre template une classe implémentant le comportement de getMove (classe de politique), est-ce que cela solutionnerait ton problème? Cela ne correspond pas tout à fait à la virtualité pure mais peut-être que cela suffit dans ton cas?

Citation:

---

Envoyé par Aleph69

Bonsoir,

et si tu passais en paramètre template une classe implémentant le comportement de getMove (classe de politique), est-ce que cela solutionnerait ton problème? Cela ne correspond pas tout à fait à la virtualité pure mais peut-être que cela suffit dans ton cas?

---

Je dois dire que j'ai du mal à imaginer cette solution. Pouvez vous me donner un exemple, ou même détaillé l'explication, s'il vous plait ?

Bonjour,

tu trouveras un exemple ici.

Dans cet exemple, on fait varier le comportement de Accumulation en lui passant en paramètre une Operation devant nécessairement avoir pour fonction membre une fonction statique Accumuler (on n'est pas forcé de la prendre statique). Ensuite, il suffit de définir les opérations que l'on veut (Addition, Multiplication, ...).

De façon similaire, tu pourrais passer en paramètre template une classe Move, ayant pour fonction membre une fonction getMove.