[Template] Question sur la programmation générique

Bonjour à tous,

j'ai une classe générique qui dépend d'un certain type T :

Code:

---

1 2 3 4

template<typename T> class maClasse { public:... };

---

Je souhaite programmer une fonction qui aurait comme valeur de retour une instance de cette classe. Le problème est que je ne connais pas avant l'exécution le type associé à ma classe. Je ne peux donc pas utiliser un code du genre :

Code:

---

template<typename T> maclasse<T>* mafonction(){}

---

Parce que là, avant d'appeler la fonction je dois connaitre le type, ce qui n'est pas le cas !
Quelqu'un aurait une idée?

D'avance merci !

Bonjour,
Une solution serai que ta classe "maClasse" hérite d'un type de base, ainsi ta fonction renverrai un pointeur sur ce type de base:

Code:

---

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

class maClasseMere { //déclaration des méthodes virtuel non template }   template<typename T> class maClasse : maClasseMere { //surcharge des méthodes virtuel non template public:... };   maClasseMere* mafonction(){}

---

Le problème c'est que tu ne pourra pas surcharger tes méthodes template puisque tu ne pourra pas les déclarer dans ta class mere.

Dans tout les cas, les paramètre template doivent être connue a la compilation, donc ce n'est peut-être pas ce qu'il te faut. Mais difficile de te faire une réponse plus précise sans avoir plus d'info sur le contexte.

Salut,
Ce qu'il faut comprendre avec les templates c'est qu'il s'agit de faire des 'gabarits' (traduction littérale de template) de classes/méthodes. Mais ensuite, ces gabarits prennent corps dans une réalisation (je ne sais pas quel est le mot exacte) lors de la compilation en précisant les arguments donnés. La résolution est donc à la compilation et pas à l'exécution.
Si ta fonction est du genre:

Code:

---

1 2 3 4 5 6 7 8 9 10

template<typename T> maclasse<T>* mafonction(int _iType) { if(42==_iType){ return new maclasse<A>(); } else{ return new maclasse<B>(); } }

---

Alors ce n'est pas possible car la résolution serait faite à l'exécution.
Pour cela tu dois, soit templatiser ta fonction puis en faire une spécialisation (1), soit utiliser une classe de base (2).
(1):

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// class traits des types: template<int T_i> struct stType; template<>struct stType<1>{typedef int type;}; template<>struct stType<2>{typedef double type;};   // prototype de la fonction template<int T_i> std::vector<typename stType<T_i>::type > CreerVecteur();   // specialisations : template<> std::vector<typename stType<1>::type > CreerVecteur<1>() { return std::vector<int>(); }   template<> std::vector<typename stType<2>::type > CreerVecteur<2>() { return std::vector<double>(); }

---

Mais là, c'est pareil: à l'appel le paramètre doit être connue en compilation:

Code:

---

1 2 3 4

CreerVecteur<1>();// Oui CreerVecteur<2>();// Oui int iValeur CreerVecteur<iValeur>;// Non

---

(2) Doublé sur le fil par Nogane

Citation:

---

Envoyé par Nogane

Dans tout les cas, les paramètre template doivent être connue a la compilation, donc ce n'est peut-être pas ce qu'il te faut. Mais difficile de te faire une réponse plus précise sans avoir plus d'info sur le contexte.

---

En gros, le type de la classe dépend du type de l'image que je vais lire. Image 8 bits, 16 bits ...etc

Alors il faut passer par une classe de base comme donné en exemple par Nogane.