1 classe template - differentes methodes

Salut,

j'implemente une class template avec 1 methode public, par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

template <typename T> class MaClasse { ... public: void methode1(void); ... }   template <class T> void MaClasse<T>::methode1() { ... }

---

que je j'utilise sur 2 types:

Code:

---

1 2	MaClasse<type1> _objet_type1; MaClasse<type2> _objet_type2;

---

Supposons maintenant que _objet_type2 ait aussi besoin d'une seconde methode (par exemple: void methode2(void)) non implementable pour _objet_type1. Elle ne peut donc pas figurer dans le corps de la template...

(Note: les structures de _objet_type1 et _objet_type2 sont telles que les 2 classes pourraient tres bien deriver d'une meme classe commune.)

Peut-on combiner heritage et template? Ou bien existe-t-il une solution plus simple ne faisant pas appel a l'heritage?

Merci

Citation:

---

Envoyé par jmeuf

Supposons maintenant que _objet_type2 ait aussi besoin d'une seconde methode (par exemple: void methode2(void)) non implementable pour _objet_type1. Elle ne peut donc pas figurer dans le corps de la template...

---

Alors il te faut créer deux classes séparées, c'est clair.
Si les deux objets ne peuvent pas être traités de la même manière....

Héritage et template ne devrait pas poser de problèmes!

Ok. Je vais chercher plutot du cote de l'heritage alors.

Merci pour ton conseil.

Est-ce que je peux deriver une classe a partir d'un template, genre:

template <typename T>
class MaClasse
{
}

...

class AutreClasse : public MaClasse<T>
{
}

Est-ce possible?
Si oui, la classe derivee est-elle aussi une template?
Ou bien doit-je d'abord specialiser la template puis deriver a partir de la specialisee (ce qui fait peut etre un peu perdre l'interet d'un template...) ???

Un template n'est qu'un modèle, mais ses instanciations sont des classes. Donc tu peux très bien en dériver :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class MaClasse : public MonTemplate<int> {   };   // Ou encore...   template <typename T> class MaClasse : public MonTemplate<T> {   };

---

Par contre pour en revenir à ton problème initial, j'ai un peu de mal à voir ce que tu cherches à faire. Tu pourrais nous en dire plus (notamment donner le contexte réel) ?

Citation:

---

Envoyé par jmeuf

Supposons maintenant que _objet_type2 ait aussi besoin d'une seconde methode (par exemple: void methode2(void)) non implementable pour _objet_type1. Elle ne peut donc pas figurer dans le corps de la template...

---

Un membre (non virtuel) n'est instancie que s'il est utilise. Donc ca ne devrait pas poser de probleme.

Je construit un ensemble de modules qui, interconnectes, permettent d'effectuer des calculs sur un espace 3D (3D reel -> 1D reel) du genre: densite (espace 1D) dans un volume (espace 3D).

Chaque module represente une fonction mathematique sur l'espace 3D et est derive d'un 'module generique' qui est une classe abstraite. Un module peut avoir un nombre d'entree differents (de 0 a 4 actuellement, mais sans que se soit limite), d'ou la derivation depuis une classe commune. Chaque module a 1 seule sortie. Chaque module a un jeu de parameters different.

Je souhaite effectuer la configuration des modules (connection / deconnection) au runtime. Je suis actuellement en mode console, mais j'ai l'intention de passer plutard en fenetre.

Chaque classe de module est encapsulee dans une 'list' qui implemente un <vector> de cette classe de module (d'ou les differents 'types abstraits')avec toutes les fonctions qui permettent d'acceder, parametrer, connecter et deconnecter les modules.

L'objet de niveau superieur est un 'repository' de modules qui instancie un objet de chaque 'list' (donc de chaque classe de module).

Enfin l'objet de plus haut niveau est le calculateur qui instancie un modele d'espace d'entree-sortie (3D et 1D) ainsi qu'un 'module repository' et effectue le calcul final une fois les modules configures.

Mon probleme est de ne pas avoir a re-ecrire toujours les meme fonctions d'acces au niveau des 'listes de modules', ou en tous cas de ne re-ecrire que ce qui est specifique a chaque classe de module.

Pour resumer:
module generique > module operationel > liste de module ops > repository > calculateur (> application, bien sur...).

Et pourquoi pas une spécialisation ? Bien sur dans le cas ou tu as beaucoup de classes suivant le modèle par défaut.

La specialisation a l'air de se rapprocher le plus de mon probleme, mais je n'arrive pas a voir comment implementer ça dans mon cas. J'ai lu et relu la FAQ a ce sujet.
Si on considere, par exemple:

template <typename T>
class Module // module generic
{
// du code applicable a toutes
// les classes de modules (methodes et proprietes)
}

template <>
class Module<Abs> // si Abs est le module realisant la fonction "valeur absolue", par exemple, et ayant sa propre classe
{
// et la, est-ce que je met le code specific au module Abs ?
// (methodes et proprietes) ?? Est-ce que le code 'generic' va etre genere
// a l'instanciation d'un module Abs ?
}

// instanciation d'un module Abs:
Module<Abs> module1;

En fait, je me dois de preciser que les 'types' qui entrent dans la classe template ne sont pas des types predefinis, mais des classes (se sont les modules operationels):

template <typename T>
class ListModule
{
//
}

ListModule<Abs> ListAbs; //Abs est une classe et ListAbs une list (<vector>) de modules de type Abs.

Si ça peut aider...

Dans le post ci-dessus il est plus correct de remplacer 'module' par 'liste de modules du type...'