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.