Discussion :

[urinou]

Hello, je débute en C++, et me voila déjà bloqué

Je cherche à utiliser un comparateur avec template, pour trier des tableaux.

Cependant, je ne sais pas comment dire à mon compilo qu'une de mes variables local est en vérité un intervalle défini par un template.

Voici la partie du code qui pose 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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
template <int DIMCOUNT> class MyClass // 1er template
{
	typedef Node....
	indexs *....
 
	...
	// Fonction de comparaison<CurrentDim>
	template <int CurentDim>
		struct My_less_equal: public std::binary_function<Node, Node, bool> {
			bool operator()(const Node& _Left, const Node& _Right) const {
				return (_Left.data[CurDim] <= _Right.data[CurDim]);
			}
	};
 
 
	....
	// ici le problème
	for (unsigned i=1; i<DIMCOUNT; i++) {
		std::sort(indexs[i][0], indexs[i][size], My_less_equal<i>());
		// error C2971 une variable local ne peut pas être utilisé comme argument
	}
	// ne fonctionne pas
 
	// J’aimerais qu'il fonctionne de la même manière que:		
	std::sort(indexs[0][0], indexs[0][size], My_less_equal<0>()); //=> ok
	std::sort(indexs[1][0], indexs[1][size], My_less_equal<1>()); //=> ok
	std::sort(indexs[2][0], indexs[2][size], My_less_equal<2>()); //=> ok
	// Version qui fonctionne pour DIMCOUNT = 3
	...
}

Le compilateur n’a tout à fait tord, mais a la compilation une fois le code déroulé, ma variable litigieuse devient une constante.

[Selenite]

Le paramètre d'un template ne peut pas être dynamique. Il doit être déterminé à la compilation. La raison est que le compilateur prends chaque My_less_equal<i> comme un type différent. A chaque fois qu'il rencontre un My_less_equal<i> avec une nouvelle valeur de i, il le compile. Ce processus de compilation ne peut évidemment pas se faire à l'exécution.

Quand tu écris ceci (*), le compilateur n'est pas assez malin pour voir que i prend des valeurs entre 1 et DIMCOUNT. Et même s'il l'était, il ne connaitrait pas la valeur de DIMCOUNT. Il ne pourrait donc pas compiler tout les My_less_equal<i> correspondants.

(*)

Code :

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

1
2
3
 
for (unsigned i=1; i<DIMCOUNT; i++)
      std::sort(indexs[i][0], indexs[i][size], My_less_equal<i>());

Si DIMCOUNT est statique, tu peux utiliser des méthodes de méta-programmation.
Mais avant tu doit surtout te demander si ton architecture est bonne, si tu as bien fait de mettre certains paramètre en templates.

[urinou]

je me doutais un peu de la réponce.

j'ai remplacé ma boucle par un :

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
 
		if (DIMCOUNT > 0) {
			std::sort(indexs[0], indexs[0] + size, D_less_equal<0>());
		} if (DIMCOUNT > 1) {
			memcpy(indexs[1], indexs[0], sizeof(void *) * size);
			std::sort(indexs[1], indexs[1] + size, D_less_equal<1>());
		} if (DIMCOUNT > 2) {
			memcpy(indexs[2], indexs[1], sizeof(void *) * size);
			std::sort(indexs[2], indexs[2] + size, D_less_equal<2>());
		} if (DIMCOUNT > 3) {
			memcpy(indexs[3], indexs[2], sizeof(void *) * size);
			std::sort(indexs[3], indexs[3] + size, D_less_equal<3>());
		} if (DIMCOUNT > 4) {
			memcpy(indexs[4], indexs[3], sizeof(void *) * size);
			std::sort(indexs[4], indexs[4] + size, D_less_equal<4>());
		} ...

le résultats compilé est le meme si le compilot sais droper les block

Code :

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

1
2
3
4
 
if (0 == 1) { // false
...
}

La seul différance dans le code, est bien sur le nombre de ligne.
C moins beau mais au moin ça marche.

au final le code complet me donnera une class pour manipuler des ensembles de vecteur à DIMCOUNT dimension.

[Luc Hermitte]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct My_less_equal: std::binary_function<Node, Node, bool>
{
    My_less_equal(ssize_t dim) : dim_(dim) {}
 
    bool operator()(const Node& _Left, const Node& _Right) const
    { return (_Left.data[dim_] <= _Right.data[dim_]); }
private:
    ssize_t dim_;
};
...
for (ssize_t i=1; i<DIMCOUNT; ++i)
{
    std::sort(indexs[i][0], indexs[i][size], My_less_equal(i));
}

?

Mais ces manips me paraissent suspicieuses. Probablement de ne pas connaitre les types manipulés, ni ce qui doit être trié.

[urinou]

Effectivement le premier code ne fonctionnais pas :p
mais apres debug, mon code fonctionne.

la fnc de comparaison est devenu :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
	typedef UPointPond<T,DIMCOUNT> Node;
	typedef Node *PNode;
 
	PNode *index; // je n'ai plus qu'un seul tableaux
 
	template <int CurDim>
	struct D_less_equal: public std::binary_function<PNode, PNode, bool>
	{
	bool operator()(const PNode& _Left, const PNode& _Right) const{	// apply operator<= to operands
			return (_Left->data[CurDim] <= _Right->data[CurDim]);
		}
	};

et pour le trie:

Code :

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

1
2
3
 
		const int d = 0;
		std::sort(index, index + _size, D_less_equal<d>());

et la ça marche.

je compte publier ma lib en Open source, une fois, fini, j'en ai mare de recoder les même chose pour chaque client.

[urinou]

Merci à ceux qui on essayé de m'aider, mais j'ai trouvé la solution.

un code du style:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
template<int DIMCOUNT>
 
 ...
  for (unsigned i=0; i<DIMCOUNT; i++) {
      fnc(i);
  }
 ...
 
 void fnc() {
   // code
 }

ne fonctionne pas, par contre si on le réecrit de manière récursive, le compilo ne renvoie plus d'erreur:

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<int DIMCOUNT>
 
 ...
 fnc<DIMCOUNT-1>(); // remplace la boucle for
 ...
 
 template <int i>
   fnc() {
     // code
     fnc<i-1>(); // appel récursif
   }
 
 template <>
   fnc<0>() { // fin recursion
     // code
   }

à part le fait que la boucle for soit parcouru à l'envers, le code produit est le meme.

CQFD à suivre