Héritage ou template

Version imprimable

Bonjour,

Je n'ai pas fait de conception depuis tellement longtemps...je n'y arrive plus :?
Je vous expose mon cas, j'ai 2 sortes de capteurs (objets c++ capteurs), certains à 3 axes, d'autres à 1 axe.
Un capteur a 3 variables membres : offset, sensibilite et mesures.

La différence entre les 2 est juste le type de ces variables.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Capteur1D{ protected : float offset; float sensibilite; std::deque<int> mesures; }; class Capteur3D{ protected : Vector3f offset; Matrix3f sensibilite; std::deque<Vector3f> mesures; };
Vector3f et Matrix3f sont des types de la librairie Eigen.

Au début, je voulais faire un héritage d'une classe mère capteur, mais plus ça va, plus je me dis, que faire une seule classe avec un template serait peut être plus approprié.
C'est voter avis ?
Et comment faire ?

16/04/2013, 10h37
koala01

Salut,

L'utilisation des template est systématiquement intéressante lorsque tu ne sais pas forcément "quel type de donnée" tu vas manipuler mais que tu sais par contre "comment" tu vas les manipuler.

L'héritage quant à lui ne peut être utilisé que lorsque LSP est pleinement respecté et que tes classes dérivées ne sont pas soumises à des post conditions plus restrictives que ta classe de base.

Nous ne pourrions donc pas envisager de faire hériter une classe "liste triée" d'une classe "liste", pas plus que nous pourrions envisager de faire hériter la classe "carré" de la classe "rectangle".

Mon sentiment est que, dans le cas présent, tu sais parfaitement comment manipuler les différents objets, même si tu n'as pas la certitude de savoir quel types d'objets il te faudra manipuler et que tu te trouves, avec tes capteurs, dans une situation sommes toutes fort similaire à celles que j'ai mises en avant avec mes classes "listes triée" et "carré" :D

Je partirais donc sans doute du principe d'une programmation générique (basée sur les template), quitte à prévoir une série de traits de politique pour la "gestion fine" (lorsqu'il faut, par exemple, prendre en compte le fait que tu as plusieurs axes) parce qu'il y aura très clairement des "points de variation" entre l'utilisation de tes capteurs ;).
16/04/2013, 10h38
ternel

Bonjour,
effectivement, je partirai plus sur une template. Du moins, tant que je n'ai pas vu comment l'utiliser.

edit: pour le reste, tout comme Koala01

Ceci dit, il est tout à fait possible qu'une classe template hérite d'une classe non template et inversément.

Avec l'héritage multiple, le CRTP et les template, tu peux donc faire des choses particulièrement intéressantes si ton besoin est de maintenir différents types de capteurs dans une seule et même collection ;)

Tu pourrais donc parfaitement envisager d'avoir quelque chose comme

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
/* tous tes objets sont visitables, et peuvent être placés dans une même 
 * collection de style std::vector<Visitbable*>
 */
class Visitable{
    public
        virtual void accept(Visteur & ) = 0;
        virtual void accept(ConstVisiteur &) const = 0;
};
/* les classes template sont définies "par ailleurs" */
class Capteur1Point : public Visitable,
                             public Capteur<1>
{
    /* ... */
};
class Capteur2Points : public Visitable,
                             public Capteur<2>
{
    /* ... */
};
class Capteur3Points : public Visitable,
                             public Capteur<3>
{
    /* ... */
};

16/04/2013, 11h13
eghza

Merci pour vos réponses, c'est bien ce qui me semblait aussi ;)
Mais je n'ai jamais fait de template, ça fait un peu peur, je vais aller lire les tutos.

Il n'y a pas de raison.

une template n'est jamais qu'un "typedef laissé à l'utilisateur".
Il s'agit de dire, je manipule un "je-ne-sais-pas-quoi", mais très précis.

Tu saurais lire ceci:
Code:

1 2 3 4 5 6 7 8 typedef int T; T max(T a, T b) { return a < b ? b : a; } int main() { int a=1, b=2; return max(a, b); }
Alors template signifie essentiellement pour tout type T
Code:

1 2 3 4 5 6 7 8 9 10 11 12 template <typename T> T max(T a, T b) { return a < b ? b : a; } int main() { int a=1, b=2; max(a,b) float c=1.f, d=2.f; max(c, d); max<int>(a,d); return 0; }
Pour la suite, lis la faq, notemment les explications sur le mot clé "typename" qui signifie "ceci est un type"