Discussion :

[themadmax]

Bonjour,

J'ai une classe Point template pour géré des coordonnées 2D :

Code :

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

1
2
3
4
5
6
7
8
class Point
{
public:
	T _x ;
	T _y ;
 
	Point( T x, T y ) : _x(x), _y(y) {}
};

Je peux donc l'utilisé avec des int ou des doubles... Mais j'aimerai faire une spécification pour faire une conversion:

Code :

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

1
2
3
4
Point<int> p1(1,2);
Point<double> p2(3.2,4.7);
p2 = p1;
p1 = p2;

Donc je me suis tourné vers une surcharge de l’opérateur d'affectation. Il me faudra spécialisé ensuite...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class Point {
    [...]
    template<class U>
    Point<T>& operator=(const Point<U>& p);
};
template<class T,class U>
Point<T>& Point<T>::operator=(const Point<U>& p)
{
	_x = p._x ;
	_y = p._y;
	return (*this);
}

Mais la mon compilo (Visual) ben il veux pas :

1>error C2244: 'Point<T>::operator =' : unable to match function definition to an existing declaration
1> definition
1> 'Point<T> &Point<T>::operator =(const Point<U> &)'
1> existing declarations
1> 'Point<T> &Point<T>::operator =(const Point<U> &)'

Sa ce ressemble beaucoup quand même...

Voila, est ce que je tiens la bonne voie ? Merci d'avance

[rincevent_123]

Salut,

Voici la syntaxe correcte pour ton problème:

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
 
template<class T>
class Point {
    [...]
    template<class U>
    Point<T>& operator=(const Point<U>& p);
};
 
template <class T>
template <class U>
Point<T>& Point<T>::operator=(const Point<U>& p)
{
	_x = p._x ;
	_y = p._y;
	return (*this);
}

[themadmax]

Merci, donc voila mon code fonctionnel avec la spécialisation pour la conversion double vers int. Si il existe d'autre solution je suis preneur.

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
template<class T>
template<class U>
Point<T>& Point<T>::operator=(const Point<U>& p)
{
	_x = p._x ;
	_y = p._y;
	return (*this);
}
 
template<>
template<>
Point<int>& Point<int>::operator=(const Point<double>& p)
{
	_x = (int)(p._x + .5) ; //Arrrondi a l'entier sup.
	_y = (int)(p._y + .5) ;
	return (*this);
}

[rincevent_123]

Ca me parait pas mal.
Après tu devrait rajouter un static_cast<T> pour la conversion de x et y dans la version générale, mais bon c'est du détail.

Sinon il faut voir tes besoins mais si tu es interessé particulièrement pour le double -> int alors c'est la meilleure solution. Mais si tu commence a vouloir spécialisé pour pas mal de combinaison de type ça peut vite devenir compliqué.