Généricité et polymorphisme

Bonjour a tous,

Je viens avec un problème un peu délicat du au fait que j'essaye de templatisé au maximum quand c'est possible.

Je travaille sur des représentations graphiques 2D qui suivent des normes. Il en existe de différent type et elles ont des similitudes.

Juste pour vous mettre dans le contexte, il s'agit de PMI (si vous ne savez pas ce que c'est, c'est pas grave). En bref, ce sont des objets 2D qui sont composés (de manière simplifié) :

• D'une ligne
• Avec, à un premier bout, un «terminator», soit une flèche, un petit carré, …
• Et a l'autre bout, un texte entouré dans une figure (carré, cercle, …)

La façon d'assembler le bouzin est dépendant de l'objet.

Précisons un truc, tant qu'il est encore temps, toutes les descriptions de ces objets sont dynamiques ! Donc, j'obtiens à l'exécution un nombre qui me dit de quelle type est la figure, etc.

Donc, il y a peu, je commence à bosser sur une première PMI. Tout d'abord, je décompose le truc, je crée des classes pour les figures, pour gérer le texte, etc.

Je me suis rendu ensuite compte que cette PMI est définie par principalement deux normes, c'est à dire qu'elles définissent les grandes lignes de la PMI. A savoir, un terminator fixe, une figure fixe, ect. Du coup je me suis dit «template à l'horizon». J'ai fait une classe pour chaque norme du type :

Code:

---

1 2 3 4 5 6 7 8 9

class norm1 { typedef Square Figure; typedef Terminator1 Terminator;   // qql méthodes de constructions };   // Idem norme 2

---

Du coup dans une méthode j'ai fait ça :

Code:

---

1 2 3 4

if(norm == 1) return build(Norm1(argNorm1)); else if(norm == 2) return build(Norm2(argNorm2));

---

Et puis rouler jeunesse, plus de problème particulier, et j'étais bien content d'utiliser les templates vu que comme ça pas de pointeurs, polymorphisme, tout a la compil quoi.

Du coup, le code de mes figures est conçu en utilisant des templates, j'ai des trucs du style :

Code:

---

Frame::anchor_invariant anchorInv = frame.build(...);

---

Et puis… vint la deuxième PMI ! Alors là, c'est la fête du slip, tout est paramétrable, la figure, le terminator, … Plus moyen de grouper le tout sous un label commun… Par conséquent, je m'y résigne, va bien falloir ajouter de la virtualité ! 1 semaine plus tard, après avoir adapté le code, codé un shared_ptr (oui oui pas le droit a la STL… bref), et amélioré certains points qui ont émergés suite a de nouvelles découvertes, me voila devant une situation quelque peu délicate.

Mes deux PMI utilise des fonctions communes, je les avais templatisé pour le premier PMI, je faisais des trucs comme ca :

Code:

---

1 2 3 4 5 6 7

template <class Frame> Frame::anchor setFrame(const Frame& frame, const AnchorPnt &anchorPnt) { Frame::anchor invariant(...); text.SetFrameType(Frame::type, framePolyline); return invariant; }

---

ce qui se transforme, pour la 2eme PMI en :

Code:

---

1 2 3 4 5 6 7

shared_ptr<AnchorBasic> setFrame(const shared_ptr<FrameBase>& frame, const AnchorPnt &anchorPnt) { shared_ptr<AnchorInvariantBasic> invariant(...); text.SetFrameType(frame->getFrameType(), framePolyline); return invariant; }

---

Mais mais… Que dois-je faire ? Soit je virtualise la première PMI pour être uniforme avec la 2ème, mais bon un peu deg d'utiliser de la virtualité alors que je vivais bien sans…

Soit je fais des overloads de partout pour permettre au deux de co-exister… Mouai, pas super maintenable à moins qu'il y ait un idiome secret pour ce genre de truc ca me semble pas la solution…

Donc me voila, que me conseillez-vous ? Ou est mon erreur de conception, le truc que j'ai pas assimilé ?

Merci d'avance, et merci d'avoir lu tout ça !

Bonjour,

J'ai pas tout compris le problème et ce que tu essaie de modéliser, mais quelque chose me choque dans ta démarche :

Citation:

---

Je travaille sur des représentations graphiques 2D qui suivent des normes. Il en existe de différent type et elles ont des similitudes.
[...]
Donc, il y a peu, je commence à bosser sur une première PMI.
[...]
Et puis… vint la deuxième PMI !

---

Tu comptes corriger ton design jusqu'à avoir fait toutes les PMI ? Et si un jour ces normes évoluent tu recommences tout ?

Si ton objectif est de modéliser des PMI, alors il faut que tu détermines les points de variations de ces PMI (ce qui en distingue ou peut en distinguer une d'une autre), et ensuite tu choisis le design le plus adapté pour ces points de variation selon qu'ils soient déterminés à la compilation ou à l'execution.

Oui tu as raison, j'ai fait une erreur en ne prenant pas en compte les prochaines PMI. En fait, je les ai prises en compte mais pas sur tous les plans (les infos qu'on avait au compile-time et runtime notamment).

Mais donc, est-ce qu'il n'y a pas d'autre choix que d'utiliser de la virtualité même lorsque ca aurait pu être évité ?

En gros, oui.
Parce que le compile-time, c'est le passé du programme, alors que le run-time, c'est son présent (voire son futur)

Quand tu compile, tu connais toutes les normes existantes à ce moment là.
Toute norme créée ultérieurement est forcément ignorée.

Par contre, tu peux aussi transformer certains parametres templates en variables, pour les lire dans un fichier, par exemple.

Merci pour vos réponses.