template class : transtyping

Version imprimable

Bonjour tout le monde,
j'ai une classe template my_int qui comme son nom ne l'indique pas peut etre instancier my_int<double> ou my_int<float>,
je voudrais faire un constructeur du type, a partir d'un my_int<double> me construit un my_int<float> mais je n'arrive pas à trouver la bonne syntaxe.
Voici mon fichier .h :

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
template<typename T>
 
 
class my_int
{
	public : 
	my_int(const T value_);
	template<typename U>
	my_int(const U value_);
	template<typename U>
	my_int(const my_int<U> other_int);
	void add(const my_int<T> other_int);
	void multi(const my_double<T> d);
	T get();
 
	void operator= (const my_double<T> d);
 
	private :
	T value;
	static const char * class_name;
	static const char * class_name1;
 
	//friend void my_double<T>::add(const my_int<T> other_int);
	friend void mult<>(my_double<T> &,const my_int<T> &,const my_double<T>&);
 
};
 
#include "my_int.hpp"

et voici mon fichier hpp :

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
44
45
#include "my_double.h"
 
template<typename U> class my_int;
template<typename T>
const char * my_int<T>::class_name = "faust_mat<T>::";
template<typename T>
const char * my_int<T>::class_name1 = "faust_mat1<T>::";
 
template<typename T>
my_int<T>::my_int(const T value_) : value(value_){}
 
 
template<typename T>
void my_int<T>::add(const my_int<T>  other_int)
{
	value += other_int.value; 
}
 
template<typename T>
T my_int<T>::get()
{
	return value;
}
template<typename U>
template<typename T>
my_int<T>::my_int(const my_int<U> other_int) : value((U) value_){};
 
 
 
template<typename U>
template<typename T>
my_int<T>::my_int(const U value_) : value((T) value_){}
 
 
template<typename T>
void my_int<T>::multi(const my_double<T> d)
{
	value *= d.value; 
}
 
template<typename T>
void my_int<T>::operator= (const my_double<T> d)
{
	value = d.value;
}

Merci d'avance

24/11/2015, 17h39
Bousk

Salut,

à priori je dirais que cette syntaxe est bonne template<typename U> my_int(const my_int<U>& other_int);. Peut-être voudrais-tu aussi fournir des opérateurs de conversions operator double(); etc.

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
template<typename T>
class my_int
{
    public : 
        my_int(const T value_) : value(value_) {}
 
        template<typename U> 
        my_int(const my_int<U> & other_int) : value(other_int.get()) {}
 
        T get() const { return value; }
 
    private :
        T value;
};
 
int main()
{
    my_int<double> d(42.0);
    my_int<float> f(d);
    return 0;
}

25/11/2015, 00h14
stendhal666

Juste une question en passant, ce serait pourquoi faire?
Parce que dans l'état, tu peux initialiser my_int<T> avec un my_int<U> uniquement s'il existe un cast possible entre T et U, ce qui signifie que tu pourrais tout aussi bien utiliser directement T et U, tu n'as donc rien gagné en terme de transtypage ou je me trompe?

Tu peux regarder quelques éléments sur la question dans https://akrzemi1.wordpress.com/2013/...rasure-part-i/
Le type est un ponte, et il avoue n'avoir pas de solution parfaite
25/11/2015, 11h22
nicocat

Pour répondre à stendhal666,
c'est pour faire du calcul matriciel, j'ai des matrices en simple(float) et en double precision (double),
j'ai des operations que je suis obligé de faire en double precision et d'autre qui peuvent etre fait en
simple precision (qui sont donc plus rapide) et je voudrais juste faire un constructeur
(1) mat<T>::mat(const mat<U> mat) ainsi que l'operateur d'affectation (2) void faust_mat<T>::operator=(faust_mat<U> const& A).
Merci à groharpon42, c'était bien ce qui fallait écrire!