Discussion :

[coberle]

Bonjour,
J’ai une fonction – disons foo - qui va travailler sur des Points, qui peuvent être en 2D (p2D=(x,y)) ou en 3D (p3D=(x,y,z)). Disons que foo(Point, t) va multiplier chaque coordonnée par t. Y a-t-il un moyen de rendre foo générique (en utilisant les templates ?) pour qu’elle puisse travailler sur p2D ou p3D sans que l'on ai à écrire une fonction foo_2D (Point_2D, t) et une fonction foo_3D (Point_3D, t)?
Christian

[Rewpparo]

2 solutions avec les templates

La première c'est de faire de tes points des classes templatées

Code :

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

1
2
3
4
5
6
template <unsigned D> class Point
{
   float m_coords[D];
public:
   ...
};

et de faire ta fonction ainsi :

Code :

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

1
2
3
4
template <unsigned D> void foo(Point<D>& p_point)
{
  // Version générique pour n'importe quel D
}

2eme solution : spécialisation de template sur foo

Code :

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

1
2
3
4
5
6
7
8
9
10
template <typename T> void foo(T& p_point);
 
template <> void foo(P2D& p_point)
{
  // (Version 2D)
}
template <> void foo(P3D& p_point)
{
  // (Version 3D)
}

Personellement j'utilise la première pour toute mon algèbre linéaire, ca marche plutot bien.
Par contre je ne sais pas comment le compilateur réagira à la deuxième si tu fais foo(int) par exemple, vu que la déclaration laisse penser que ca marche, mais il n'y a pas d'implémentation.

[bretus]

Bonsoir,

Je ne vois pas l'intérêt de faire de la template spécialisée dans la deuxième solution.

Vous pouvez tout simplement faire ceci, les signatures des fonctions seront différentes :

Code :

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

1
2
3
4
5
6
7
8
9
 
void foo( Point2D & p )
{
 
}
void foo( Point3D & p )
{
 
}

Note : C'est valable aussi pour les méthodes d'une même classe et c'est les choses du style "ma_transformation" qui se retrouveront en hiérarchie ou en template.

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
 
 
struct ma_transformation {
	//...
 
	void apply( Point2D & p ){
		//...
	}
 
	void apply( Point3D & p ){
		//...
	}
 
	//...
};

[Rewpparo]

Tu as raison, j'ai pas bien réfléchi. Ca permet juste de pouvoir rajouter des implémentations sans rajouter un prototype, mais l'intéret est probablement minime dans ce cas précis.
Mais ca fait parler spécialisation de template, ce qui n'est jamais une mauvaise chose

[Trademark]

Perso j'aurais plutôt fait ça :

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 <unsigned D> class Point
{
   float m_coords[D];
public:
   static const unsigned nb_dim;
   ...
};
 
template <unsigned D> 
const unsigned Point<D>::nb_dim = D;
 
template <typename T> void foo(T& point, int t)
{
  for(int i=0; i < T::nb_dim; ++i)
  // ...
}

Et au lieu de faire de foo une fonction à part, j'aurais surcharger l'opérateur '*' pour avoir tout dans la classe. La solution du dessus permet de ne pas à avoir à repréciser le nombre de dimensions lorsqu'on appelle "foo".

[Rewpparo]

La solution du dessus permet de ne pas à avoir à repréciser le nombre de dimensions lorsqu'on appelle "foo".

Tu n'as pas a le préciser.

Code :

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

1
2
P3D p;
foo(p);

Le compilateur choisit le paramètre du template en fonction du type que tu lui passes, inutile de le repréciser avec des chevrons. Et il vérifie à la compilation que le type est un point, puisque le type passé est Point<D>. Avec un template générique T, le compilateur peut se gourer et essayer de le faire avec un type qui n'est pas fait pour.
Et ca marche également avec les opérateurs :

Code :

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

1
2
3
4
5
6
7
8
9
10
template <unsigned D> class Point
{
public:
   Point<D> operator + (const Point<D>& p_point);
   &Point<D> operator +=(const Point<D>& p_point);
   &Point<D> operator =(const Point<D>& p_point);
};
Point<D> p1, p2, p3;
p1 = p2 + p3;
p1+=p3;

Pour convertir d'un D a un autre, rajoute le constructeur de copie généralisé

Code :

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

1
2
3
4
5
template <typename D1> [explicit] Point(const Point<D1>& p_point);
Point<2> p2;
Point<3> p3, p;
p = p3 + p2;
p = p2 + p3;

Et vu que le nombre de conversions possibles est réduite, tu peux spécialiser le template et n'implémenter que les conversions acceptables.
Mais dans tous les cas je conseille largement explicit, changer la dimension d'un vecteur ca doit se faire de manière controlée car ca a un sens lourd.

Ensuite, si tu veux être vraiment finaud, tu peux utiliser une définition de classe template récursive :

Je kiffe, ce truc est tripant, j'avais jamais pensé à ca !
Par contre aucune garantie que les coordonnées sont contigues en mémoire si ? J'en ai besoin moi pour parler vite avec opengl (qui prend un pointeur vers une array)

[Obsidian]

Si tu comptes simplement te limiter aux points 2D et 3D, alors le plus indiqué est l'héritage : non seulement tu t'épargnes les difficultés liées aux templates mais, en plus, tu gardes l'aspect hiérarchique qui te permet de « dégrader » un point 3D en 2D. En héritant, tu peux établir une interface à respecter.

Et puisque tu utilises le C++, autant redéfinir les opérateurs dans ta classe, pour pouvoir directement réécrire une algèbre pour tes types, plutôt qu'utiliser une fonction ordinaire détachée de tout namespace et de contexte.

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
#include <iostream>
using namespace std;
 
// 2D
 
class Point2D
{
    public:
        double    x;
        double    y;
 
        Point2D     operator + (const Point2D &);
};
 
Point2D Point2D::operator + (const Point2D & p)
{
    Point2D out = p;
    out.x += x;
    out.y += y;
 
    return out;
}
 
// 3D
 
class Point3D : public Point2D
{
    public:
        double    z;
 
        Point3D     operator + (const Point3D &);
};
 
Point3D Point3D::operator + (const Point3D & p)
{
    Point3D out = p;
 
    out.Point2D::operator + (*this);
 
    out.z += z;
 
    return out;
}
 
int main (void)
{
    Point2D     a,b,c;
    Point3D     d,e,f;
 
    a.x = 4; a.y = 6;
    b.x = 8; b.y = 1;
    c = a + b;
 
    cout << "(" << a.x << ";" << a.y << ")" << endl;
    cout << "(" << b.x << ";" << b.y << ")" << endl;
    cout << "(" << c.x << ";" << c.y << ")" << endl;
    cout << endl;
 
    d.x = 2; d.y = 9; d.z = 7;
    e.x = 3; e.y = 4; e.z = 5;
    f = d + e;
 
    cout << "(" << d.x << ";" << d.y << ";" << d.z << ")" << endl;
    cout << "(" << e.x << ";" << e.y << ";" << e.z << ")" << endl;
    cout << "(" << f.x << ";" << f.y << ";" << f.z << ")" << endl;
    cout << endl;
 
    return 0;
}

Code Shell :

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

1
2
3
4
5
6
7
8
$ ./programme
(4;6)
(8;1)
(12;7)

(2;9;7)
(3;4;5)
(3;4;12)

Dans l'exemple ci-dessus, on voit que Point2D additionne x et y et que, ligne 3D, Point3D commence par considérer le point 3D comme un point 2D et utilise la fonction d'addition existante, puis complète l'opération en additionnant simplement z.

Ensuite, si tu veux être vraiment finaud, tu peux utiliser une définition de classe template récursive :

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
#include <iostream>
using namespace std;
 
template <int N>
class Point : public Point<N - 1>
{
    public:
                Point   ();
        void    Affiche ();
 
        int d;
};
 
template <>
class Point<0>
{
    public:
 
        int d;
};
 
 
template <int N>
Point<N>::Point () :
    d(N*2)
{
}
 
template <int N>
void Point<N>::Affiche ()
{
    if (N>1) Point<(N>1)?N-1:1>::Affiche();
    cout << d << ";";
}
 
int main (void)
{
    Point<1>    a;
    Point<2>    b;
    Point<5>    c;
 
    a.Affiche(); cout << endl;
    b.Affiche(); cout << endl;
    c.Affiche(); cout << endl;
 
    b = c;
//    c = b;
 
    return 0;
}

Code Shell :

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

1
2
3
4
$ ./programme
2;
2;4;
2;4;6;8;10;

Dans cet exemple, on peut définir n'importe quel point dans l'espace de dimension N. La ligne 25 est faite pour poser chaque terme des coordonnées est initialisé arbitrairement à « dimension × 2 » et on voit que c'est bien ce que l'on obtient en sortie.

Il y a trois avantages à procéder ainsi :

1. On n'est pas obligé de trimbaler des méta-données, ni de les initialiser. C'est utile lorsque l'on gère des milliers de points, lorsque l'on doit les sérialiser et les restaurer ;
2. Sémantiquement, on indique au compilateur la relation qui existe entre ces différents objets ;
3. Conséquence directe : on est capable de dire qu'un point<N> dérive directement d'un point<N-1>, quelque soit N. Et ça, ça nous débloque automatiquement toutes les facilités offertes par l'héritage.

Ce dernier point en particulier est mis en évidence par les lignes 46 et 47 : on peut écrire Point<2> = Point<5>, dans ce cas seuls x et y sont copiés, mais pas Point<5>=Point<2> car il manque des informations.

Ceci permet à ton compilateur de générer une erreur lui-même plutôt que confier cela au logiciel et laisser celui-ci déclencher une exception si le nombre de dimensions d'un des points est insuffisant. Et il vaut mieux car il s'agit bien d'une erreur de conception, sur la forme, mais qui pourrait ne se déclencher que beaucoup de temps après la mise en production d'un logiciel dans ce dernier cas.

À noter enfin que l'expression tordue de la ligne 32 n'est là que pour pallier une difficulté de compilation avec ma version de G++. En principe, j'aurais dû écrire une version spéciale de la fonction affiche pour la classe Point<0> en particulier.

[Luc Hermitte]

Si tu comptes simplement te limiter aux points 2D et 3D, alors le plus indiqué est l'héritage

Je ne suis pas d'accord avec l'emploi d'un héritage public.
On se traine ainsi trop de soucis à mélanger (sémantique de) valeurs et héritage.

C'est la porte ouverte à additionner Point2D et Point3D et des hacks dans tous les sens pour essayer d'avoir un code qui supporte cela. Alors que c'est un besoin inexistant.
Si dégradation il doit y avoir, qu'elle se fasse proprement -> par projection sur un plan selon un vecteur de projection.

PS: les tuples c'est bien aussi pour se simplifier la vie, plus simple que les templates récursifs. Mais bon, la solution 1 avec le tableau statique de Rewpparo est de loin la meilleure.
PPS: le code n'était pas const-correct ni symétrique (en matière de conversions implicites)