Discussion :

[tlemcenvisit]

Bonjour à tous,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[Nogane]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[3DArchi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

(2) Doublé sur le fil par Nogane

[tlemcenvisit]

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

[3DArchi]

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