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.

[Luc Hermitte]

J'avais écris des templates pour vim qui me permettent de générer ce genre de choses (NB: la dernière version en conf a quelques bugs):

Code C++ :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
#ifndef POINTS_H__
#define POINTS_H__
 
template <typename T> class Point;
template <typename T> class Dist;
namespace DETAILS
{
    template <typename T> class PointImpl_
    {
    public:
	typedef T scalar_type;
	friend class Point<T>;
	friend class Dist<T>;
    protected:
	/**@name Construction/destruction
         */
	//@{
	/** Initialisation constructor.
         */
	PointImpl_(scalar_type x_ = scalar_type(), scalar_type y_ = scalar_type())
	    : m_x(x_), m_y(y_) {}
	/** Protected destructor.
         */
	// ~PointImpl_() {}
	//@}
 
	/**@name Operations
         */
	//@{
	void add(PointImpl_ const& rhs_)
	{ m_x += rhs_.m_x; m_y += rhs_.m_y; }
	void dec(PointImpl_ const& rhs_)
	{ m_x -= rhs_.m_x; m_y -= rhs_.m_y; }
	void mult(scalar_type coeff_)
	{ m_x *= coeff_; m_y *= coeff_; }
	void div(scalar_type coeff_)
	{ m_x /= coeff_; m_y /= coeff_; }
	static bool isEqual(
		PointImpl_ const& rhs_,
		PointImpl_ const& lhs_)
	{ return rhs_.m_x == lhs_.m_x && rhs_.m_y == lhs_.m_y; }
	//@}
    private:
	scalar_type m_x;
	scalar_type m_y;
    };
}
 
/**
 * Point class.
 *
 * <p><b>Semantics</b><br>
 * <li> Value, 
 * <li> mathematical: represents a point, and not distance between
 * points
 */
template <typename T> class Point : DETAILS::PointImpl_<T>
{
public:
    friend class Dist<T>;
    typedef typename DETAILS::PointImpl_<T>::scalar_type scalar_type;
 
    /**@name Construction/destruction
     */
    //@{
    /** Initialisation constructor.
     */
    Point(scalar_type x_ = scalar_type(), scalar_type y_ = scalar_type())
	: DETAILS::PointImpl_<T>(x_, y_){}
    //@}
 
    /**@name Operators
     */
    //@{
    Point & operator+=(Dist<T> const& rhs_) { this->add(rhs_); return *this; }
    Point & operator-=(Dist<T> const& rhs_) { this->dec(rhs_); return *this; }
 
    static DETAILS::PointImpl_<T> const diff(Point const& lhs_, Point const& rhs_) 
    {
	DETAILS::PointImpl_<T> tmp(lhs_);
	tmp.dec(rhs_);
	return tmp;
    }
    friend bool operator==(Point const& rhs_, Point const& lhs_)
    { return Point::isEqual(rhs_, lhs_); }
    //@}
};
 
/**
 * Dist class.
 *
 * <p><b>Semantics</b><br>
 * <li> Value, mathematical: 
 * <li> «relative position»
 * <li> mathematical: it's a relative position, represents a distance
 * between points, and not a point
 */
template <typename T> class Dist : DETAILS::PointImpl_<T>
{
public:
    friend class Point<T>;
    typedef typename DETAILS::PointImpl_<T>::scalar_type scalar_type;
 
    /**@name Construction/destruction
     */
    //@{
    /** Initialisation constructor.
     */
    Dist(scalar_type x_ = scalar_type(), scalar_type y_ = scalar_type())
	: DETAILS::PointImpl_<T>(x_, y_){}
    //@}
 
    /**@name Operators
     */
    //@{
    Dist & operator+=(Dist const& rhs_) { this->add(rhs_); return *this; }
    Dist & operator-=(Dist const& rhs_) { this->dec(rhs_); return *this; }
    Dist & operator*=(scalar_type coeff_){ this->mult(coeff_); return *this; }
    Dist & operator/=(scalar_type coeff_){ this->div(coeff_); return *this; }
 
    friend bool operator==(Dist const& rhs_, Dist const& lhs_)
    { return Dist::isEqual(rhs_, lhs_); }
 
    template <typename U>
    friend Dist<U> const operator-(Point<U> const& lhs_, Point<U> const& rhs_);
    //@}
 
protected:
    explicit Dist(DETAILS::PointImpl_<T> const& rhs_) : DETAILS::PointImpl_<T>(rhs_) {}
};
 
template <typename T> inline
Dist<T> const operator-(
	Point<T> const& lhs_,
	Point<T> const& rhs_) 
{ return Dist<T>(Point<T>::diff(lhs_, rhs_)); }
 
template <typename T> inline
Point<T> const operator+(
	Point<T> const& lhs_,
	Dist<T> const& rhs_) 
{ return Point<T>(lhs_) += rhs_; }
 
template <typename T> inline
Point<T> const operator+(
	Dist<T> const& lhs_,
	Point<T> const& rhs_)
{ return Point<T>(rhs_) += lhs_; }
 
template <typename T> inline
Point<T> const operator-(
	Point<T> const& lhs_,
	Dist<T> const& rhs_)
{ return Point<T>(lhs_) -= rhs_; }
 
#if 0
// Makes no sense
template <typename T> inline
Point<T> const operator-(
	Dist<T> const& lhs_,
	Point<T> const& rhs_);
#endif
 
template <typename T> inline
Dist<T> const operator+(
	Dist<T> const& lhs_,
	Dist<T> const& rhs_) 
{ return Dist<T>(lhs_) += rhs_; }
 
template <typename T> inline
Dist<T> const operator-(
	Dist<T> const& lhs_,
	Dist<T> const& rhs_)
{ return Dist<T>(lhs_) -= rhs_; }
 
template <typename T> inline
Dist<T> const operator*(
	Dist<T>                const& lhs_,
	typename Dist<T>::scalar_type rhs_) 
{ return Dist<T>(lhs_) *= rhs_; }
 
template <typename T> inline
Dist<T> const operator*(
	typename Dist<T>::scalar_type lhs_,
	Dist<T>                const& rhs_)
{ return Dist<T>(rhs_) *= lhs_; }
 
template <typename T> inline
Dist<T> const operator/(
	Dist<T>                const& lhs_,
	typename Dist<T>::scalar_type rhs_) 
{ return Dist<T>(lhs_) /= rhs_; }
 
template <typename T> inline
Dist<T> const operator/(
	typename Dist<T>::scalar_type lhs_,
	Dist<T>                const& rhs_)
{ return Dist<T>(rhs_) /= lhs_; }
 
#endif // POINTS_H__

Bon, c'est un peu lourd. À l'occasion il faudra que je cherche à simplifier -- les constructeurs hérités & cie du C++0x faciliteront un peu la tâche je pense.

Le rapport avec la question de départ ?
- pas de classe abstraite
- mais une classe héritée (non publiquement) définissant les comportements de base et communs aux points et aux vecteurs (deltas, nommés à tord Dist)

Par contre, à moins de vouloir réaliser un super interpréteur d'expressions mathématiques, il n'y a pas le moindre intérêt à avoir des conteneurs pouvant héberger indistinctement des Point<double> et des Point<long long> : en dynamique, ce sera l'un ou l'autre. Jamais les deux à la fois. Lequel on prend est déterminé à la compilation. C'est alors aux fonctions d'être templatisées pour accepter une forme ou l'autre de point.
Pour moi c'est un peu le même combat que de vouloir mélanger dynamiquement des Point2D et des Point3D : une mauvaise analyse des besoins.
D'ailleurs il n'y a pas de solution technique géniale à ce problème de LSP au pays de la sémantique mathématique/de valeur.

[Flo.]

Salut,

Merci pour cette longue réponse.

J'ai essayé de comprendre ton code. Cela ressemble un peu au pattern Visiteur non ? Mais je ne parviens pas à saisir comment tu peux faire des opérations sur des template différents. Tes opérations semblent travailler sur des objets de même template.

J'ai aussi du mal à saisir cette partie :

Par contre, à moins de vouloir réaliser un super interpréteur d'expressions mathématiques, il n'y a pas le moindre intérêt à avoir des conteneurs pouvant héberger indistinctement des Point<double> et des Point<long long> : en dynamique, ce sera l'un ou l'autre. Jamais les deux à la fois. Lequel on prend est déterminé à la compilation. C'est alors aux fonctions d'être templatisées pour accepter une forme ou l'autre de point.
Pour moi c'est un peu le même combat que de vouloir mélanger dynamiquement des Point2D et des Point3D : une mauvaise analyse des besoins.

En fait j'ai pas compris si elle s'appliquait à ma modélisation initiale ou à la tienne . Tu peux préciser ton propos ?

Désolé si j'ai loupé des trucs évidents ... ...

Merci en tous cas

Flo.

[Luc Hermitte]

a- Non, il n'y a aucun rapport avec le pattern visiteur.
C'est de la simple factorisation de code.

b- Je ne fais pas des "Point<long> + Point<double>" car cela n'a pas le moindre intérêt! (hors développement d'un interpréteur mathématique)
C'est un peu comme si tu savais que les fruits se reproduisent et que tu coup tu voulais reproduire des bananes avec des poires.

c- Ma prose s'applique à tes choix. Je soupçonne que tu commettes une erreur de débutant où tu veux faire le truc ultra-générique avec tout qui marche avec tout. Sauf que l'on finit un jour par se rendre compte que l'on ne s'en sert jamais, que l'on a développé un truc super compliqué, et qu'en plus ce ne marche pas très bien sous certaines circonstances. (sans parler de la perte de vitesse à l'exécution)
Et justement ici, il y aura toujours un truc qui fera que cela ne marche pas très bien. Ou alors tu sors un système compliqué dont les deux réponses connues à ton problème (*) sont l'idiome enveloppe-lettre et le mini framework d'objets réguliers pondu chez Adobe par Sean Parent ou A.Stepanov, je ne sais plus lequel des deux, voire les deux.


(*) qui est de forcer la sémantique de valeur sur une hiérarchie polymorphe

[Flo.]

Oui oui je suis d'accord avec toi ... (je te sens un peu emporté sur ce coup ).

Mon interrogation relevait juste de la curiosité. A savoir si malgré le pattern erasure ce genre de mécanisme était possible (je ne connais que très peu de pattern). Après je suis conscient qu'ajouter un Point<double> à un Point<int> c'est pas très cohérent (ce que je faisais remarquer plus haut ...).

Flo.

[Luc Hermitte]

Du tout. Juste surpris que personne ne t'avais signalé que tu t'engageais sur une voie compliquée et sans intérêt.

[Flo.]

Je ne m'y engage pas. Je scrutais l'horizon.