Template : static VS dynamic

Version imprimable

Bonjour à tous,

Je me retrouve dans cette situation ci :
Code:

1 2 3 4 5 6 7 8 9 10 template struct Test<int A, int B> { static void run(); }; template<> struct test<0, 0> { /* code spécifique */ }; template<> struct test<0, 1> { /* code spécifique */ }; template<> struct test<1, 0> { /* code spécifique */ }; template<> struct test<1, 1> { /* code spécifique */ };
Les valeurs de A et B sont connues et comprises entre 0 et 5.

Mon soucis c'est qu'étant donné que je suis dans un mode webservice, les valeurs A et B sont passées par l'utilisateur du service en chaîne de caractères que j'aurais préalablement parsé.

Je me retrouve donc avec une fonction :
Code:

1 2 void run(int iA, int iB);
Dont le contenu doit appeler :
Code:

1 2 Test<iA, iB>::run();
Bien évidemment ça ne fonctionne pas étant donné que les paramètres iA et iB ne sont pas constants.

Alors je cherche une solution pas trop dégueulasse pour pallier contourner cette erreur.

Par exemple générer des fonctions de ce type, via probablement des macros ?
Code:

1 2 3 4 5 void run_test_0_0() { Test<0, 0>::run(); }
Ce qui serait bien c'est que ces fonctions soient générées automatiquement, parce que aujourd'hui les valeurs vont de 0 à 5, mais demain ça pourra aller jusqu'à 10, 20, 30, et ça va devenir compliqué de générer cette "matrice" de fonction.

J'ose croire qu'à la compilation, en utilisant macro et template récursif, on peut faire quelque chose du genre "GenerateFunctions<5, 5>" et que ça génère l'ensemble plutôt que le faire (et surtout le maintenir) à la main ?

Merci d'avance pour vos réponses,

A bientôt :)

14/01/2014, 15h50
Médinoc

Enregistre-les dans un conteneur genre map< pair<int, int>, void(*)() >.
14/01/2014, 16h34
Flob90

Bonjour,

Le template Test c'est toi qui l'a fait ou c'est un élément extérieur ?
14/01/2014, 16h49
mister3957

Citation:

Envoyé par Flob90

Bonjour,

Le template Test c'est toi qui l'a fait ou c'est un élément extérieur ?

C'est moi qui l'ai fait.

Mais je suis en train d'implémenter la solution de l'enregistrement des pointeurs de fonction dans une map, je pense que ça va fonctionner.
14/01/2014, 17h23
Flob90

Donc tu ne "te retrouve" pas avec ce code, tu as "pris la décision de l'écrire". Personnellement c'est ceci que je remettrais en cause. Quel intérêt d'avoir ce code avec des paramètres template si les arguments pour l'utiliser ne sont connus qu'à l’exécution ? On ne devrait choisir un paramètre template que lorsque l'information est connu à la compilation, ce n'est pas ton cas, alors pas de paramètre template.

Pour donner une image, là tu me dis, "j'ai pris une vis mais j'arrive rien à en faire avec mon marteau", alors oui tu vas pouvoir utiliser ta vis en adaptant un embout sur ton marteau, mais pourquoi ne pas tout simplement prendre un clou ?

Personnellement, je vois le besoin d'un comportement variant selon deux paramètres, les solutions que j'envisage passent par des structures conditionnelles résolues à l’exécution, que ce soit directement des if ou bien des tables d'association. Mais pas par des structures conditionnelles résolues à la compilation, qui n'aurait aucun intérêt.

Edit: Et à la place des pointeurs de foncteur, préfère un std::function, c'est à la fois plus simple à utiliser et plus flexible.
14/01/2014, 18h08
mister3957

C'est compliqué ;)

Mais cette solution d'enregistrer les fonctions dans une map est une bonne solution dont le traitement peut-être généré via la méta programmation, et ne sera exécutée qu'à l'initialisation de la brique logicielle en question, soumis à des contraintes de performance et de volumétrie.

C'est pourquoi j'ai préféré utiliser des tableaux en C ainsi que la méta programmation de manière massive.

Reste à faire le lien entre ce qui relève du domaine de l'utilisateur, accessible en web service, et ce qui relève du domaine interne.

Mais cette solution d'enregistrer les fonctions appelées dans une map indexées est une bonne solution dans la mesure ou l'utilisation de ces outils ne seront sollicité qu'à l'initialisation de la brique logicielle, pas dans son traitement de recherche combinatoire, alors ça me va ;)

Je préfère attendre d'avoir validée cette solution à mon problème afin de marquer le sujet "résolu" ;)

C'est bon :)

J'ai fait un truc de ce style :

Code:

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
 
typedef std::map<int, void(*)(int, const std::string&) > Row;
 
template<int From, int To, template<int, int> class Call, int COL>
struct SRegisterRow {
	static void run(Row& row) {
		Call<From, COL>::run(row);
		SRegisterRow<From + 1, To, Call, COL>::run(row);
	}
};
 
template<int Ended, template<int> class Call, int COL>
struct SRegisterRow<Ended, Ended, Call, COL> {
	static void run(Row& row) {
 
	}
};
 
template <int ROW, int COL>
struct SRegisterRowCall {
	static void run(Row& row) {
		row[COL] = &Test<COL, ROW>::MyFunction;
	};
};
 
typedef std::map<int, Row> Data;
 
template<int From, int To, template<int> class Call>
struct SRegisterData {
	static void run(Data& data) {
		Call<From>::run(data);
		SRegisterData<From + 1, To, Call>::run(data);
	}
};
 
template<int Ended, template<int> class Call>
struct SRegisterData<Ended, Ended, Call> {
	static void run(Data& data) {	}
};
 
template <int COL>
struct SRegisterDataCall {
	static void run(Data& data) {
		SRegisterRow<0, SInfo<COL>::s_iRowCount, SRegisterRowCall, D>::run(data[COL]);
	};
};
 
Data d;
SRegisterData<0, COL_COUNT - 1, SRegisterDataCall >::run(d);

Utilisation :

Code:

1
2
3
4
5
 
void MyFunction(int iCol, int iRow, int val1, const std::string& val2)
{
   d[iCol][iRow](val1, val2);
}

Merci à vous :)