peut-on redéfinir le type template pour une même instance ?

Version imprimable

Bonjour,

Je rencontre un cas ou j'aimerais pouvoir changer le type Template pour une même instance. J'expose un exemple plus parlant:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
template <class result_type>
struct data
{
	result_type dt;
};
 
template <class result_type>
class processing
{
	private:
	data* d_;
 
	public:
	processing(data* d);
	void processing_function(result_type result);
	processing& operator=(const processing& o) = default;
};
 
template<class result_type>
inline processing<result_type>::processing(data * d) : d_(d)
{
}
 
// SETTER
template<class result_type>
inline void processing<result_type>::processing_function(result_type result)
{
	d_->dt = result;
}
 
int main(int argc, char* argv[])
{
 
	data<int> da;
	da.dt = 10;
	processing<int> p(&da);
	p.processing_function(308);
 
	/* Peut-on garder les données de l'instance tout en modifiant le type template ? */
	p.processing_function("test");
 
	return 0;
}

Merci d'avance pour vos suggestions ou vos modifications de code.

Salut,

Malheureusement, les paramètres template (ce qui remplace <class result_type> pour ta classe Data, par exemple) sont évalués à la compilation, ce qui fait que:
le compilateur doit connaitre le type qui remplace ce paramètre avant même de pouvoir générer le code binaire correspondant
A moins de changer ce type dans le code (de remplacer data<int> da; dans ta fonction principale par data<double> da; par exemple), une fois que ce paramètre est donné, il l'est de manière définitive.

Ceci dit, il est toujours possible de faire hériter ta classe template d'une classe de base qui ne l'est pas, et, sous réserve de respecter les règles qui permettent de profiter du polymorphisme, d'instancier plusieurs spécialisation de cette classe template et de toutes les utiliser comme s'il s'agissait de la classe de base

Ainsi, un code proche de
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 class Base{ public: Base(Base const &) = delete; Base & operator=(Base const &) = delete; virtual ~Base() = default; virtual void doIt() const = 0; }; template <typename T> class Derived : public Base{ public: void doIt() override{ /* ... */ } }; void excute(Base const & b){ b.doIt(); } int main(){ Derived<int> dInt; Derived<double> dDouble; execute(dInt); execute(dDouble); return 0; }
sera tout à fait légal et réagira exactement comme prévu (tu pourrais d'ailleurs envisager l'utilisation du patron de conception visiteur, si le nombre de classes concrètes n'est pas trop important).

Tu peux également complètement cacher ce genre de hiérarchie au sein d'une classe qui "aura tout" d'une classe non template, excepté son constructeur. Cela te permettrait de faire cohabiter plusieurs types de données ensemble.

Un exemple classique de cette possibilité est la classe boost::any.

17/10/2016, 10h24
Bousk

Et en mettant le template ailleurs qu'au niveau de la classe et en utilisant des fonctions de conversion ?