Discussion :

[Flo.]

Bonjour,

J'ai une classe templat�e PointT h�ritant d'une classe abstraite Point.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
class Point
{	
public:
	Point()
	{
 
	}
 
public: virtual void ToString() = 0;
};

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
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
46
47
48
49
50
51
52
53
54
55
template<typename T> class PointT : public Point
{
public:
	T x;
	T y;
 
public:
	PointT() : x(0), y(0)
	{
 
	}
 
public:
	PointT(T a, T b) : x(a), y(b)
	{
 
	}
 
public:
	PointT<T> & operator = (PointT<T> & point)
	{
		this->x	= point.x;
		this->y	= point.y;
		return *this;
	}
 
public:
	PointT<T> operator + (PointT<T> & point)
	{
		PointT<T> a;
		a.x	= x + point.x;
		a.y	= y + point.y;
		return a;
	}
 
public:
	template<typename T2> PointT<double> operator + (PointT<T2> & point)
	{
		PointT<double> tempA = point;
		PointT<double> tempB = *this;		
		return tempA + tempB;
	}
 
public:
	template<typename T2> inline operator PointT<T2> ()
	{
		return PointT<T2>( (T2)x, (T2)y );
	}
 
public: 
	void ToString()
	{
		cout <<  (double)x  << " "  << (double)y  << endl;	
	}
};

J'arrive � faire des choses comme

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
PointT<int> a(1, 2);
PointT<float> b(10.5, 11.6);
PointT<double> c = a + b;

J'aimerais � pr�sent faire la m�me chose directement au niveau de la classe m�re, c'est � dire, additioner 2 objets de type Point et r�cup�rer un objet de type PointT<double>.

Telles que sont d�finies mes classes je n'y arrive pas. J'ai pens� � d�localiser mon x et mon y dans la classe m�re en changeant leur type en boost::any.

Mais est-ce la bonne solution ?

Flo.

[poukill]

Ok je vois. Le type erasure c'est pour pouvoir stocker tes points dans un conteneur, m�me s'ils n'ont pas le m�me type c'est bien �a ? Est-ce vraiment ce que tu veux ?
Le truc c'est que si tu manipules tout par la classe m�re, tu perds le type r�el.

Ton cas peut se r�soudre avec un m�canisme de visitor, mais je pense qu'il faudrait d�river encore d'un cran pour faire appara�tre des classes non templat�es... C'est un peu lourd quand m�me, mais �a se fait !

[Flo.]

Erasure oui.

C'est pour stocker mes points dans un vector et pour pouvoir, par la suite, les manipuler ind�pendamment sans se pr�occuper de leur type. Pour l'instant, je n'ai pas besoin d'op�ration comme l'addition de 2 Point. C'est plut�t par curiosit�.

D'ailleurs, je ne sais m�me pas si une telle op�ration � sa logique.

Et au passage, avec boost::any, je n'y arrive pas non plus car au moment du boost::any_cast, dans la classe m�re, il me faut conna�tre le type T de la classe fille.

Merci pour la r�ponse.

Flo.

[jblecanard]

Et au passage, avec boost::any, je n'y arrive pas non plus car au moment du boost::any_cast, dans la classe m�re, il me faut conna�tre le type T de la classe fille.

H� oui.

Dans ce cas, je vois au moins deux solutions :
- Utiliser un std::vector<boost::any>, et mettre tes points dedans.
- Utiliser un std::vector<boost::variant>. Ca t'oblige � lister les types stockables mais �a se fait bien.

[poukill]

Et au passage, avec boost::any, je n'y arrive pas non plus car au moment du boost::any_cast, dans la classe m�re, il me faut conna�tre le type T de la classe fille.

C'est ce que je disais avec "tu perds le type r�el". Tu es coinc�.
Maintenant, tu peux faire �a avec des visiteurs. C'est clairement "intrusif" dans le sens o� il faut modifier l'interface de la classe, mais �a fait le boulot.
C'est une troisi�me solution !

[koala01]

Salut,

Tu devrais pouvoir t'en sortir � coup de double dispatch, sous une forme proche de (code non test�):

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
21
22
23
24
25
26
27
28
29
30
31
32
template <typename T> PointT;
class Point
{
    public:
       /* permet de passer n'importe quel spécification de pointT, et d'obtenir
        * un point représenté sous la forme de doubles
        */
        template <typename T>
        pointT<double> operator + (typename pointT<T> const & other) const
        {return other.doAdd(*this);}
};
template <typename T> PointT : public Point
{
    protected:
        PointT<Double> doAdd(PointT<int> const & other) const
        {
            // la logique adaptée
        }
        PointT<Double> doAdd(PointT<unsigned int> const & other) const
        {
            // la logique adaptée
        }
        PointT<Double> doAdd(PointT<float> const & other) const
        {
            // la logique adaptée
        }
        PointT<Double> doAdd(PointT<double> const & other) const
        {
            // la logique adaptée
        }
        /* d'autres types, peut être ??? */
};

Mais la question reste effectivement de savoir s'il est opportun de travailler de la sorte ...

On peut, en effet, comprendre que l'on renvoie un PointT<double> lorsque l'un des op�randes au moins est de ce type, par contre, je me vois mal essayer de convaincre qui que ce soit de la logique qui ferait que nous obtenions un pointT<double> lorsque l'on essaye d'additionner deux pointT</* unsigned */ int> ou un pointT<complex>

[Flo.]

Merci koala01,

Merci pour le coup de main. Malheureusement je n'ai pas r�ussi � int�grer ton code dans le mien. Je bute sur des erreurs de compilations que je ne parviens pas � r�soudre.

Quoiqu'il en soit je vais en rester l�, ma curiosit� �tant (� moiti�) rassasi� ...

Flo.