Désigner des membres par des noms

Version imprimable

18/10/2011, 17h22
oodini

Désigner des membres par des noms
Hello,

Bon, voici mon problème :

J'ai un traitement identique à faire sur des objets de types différents.
Donc, youpi, on pense à un template de fonction/méthode.

Sauf que... 5% de ce code concerne en fait des membres spécifiques à chaque type.

Pour faire simple avec les types A et B, j'aimerais faire :
Code:

1 2 pA->val1 = 5 pB->val2 = 5
avec des templates. C'est un non sens, me direz-vous. Mais n'oubliez pas les 95 % restants, qui eux profiteraient pleinement des templates.

Y a-t-il moyen de faire varier le nom du membre avec des paramètres de la méthode ? Avec des traits, ou que sais-je ?...

Merci.

ca s'appelle la spécialisation.

Code:

1
2
3
4
5
6
7
8
//generique
template< typename T > void doStuff(T* t) { t->val = 0; }
 
// version spéciale pour A
template<  > void doStuff<A>(A* a) { a->val1 = 5; }
 
// version spéciale pour B
template<  > void doStuff<B>(B* b) { b->val2 = 5; }

18/10/2011, 17h39
oodini

Si je fais ça, je n'ai plus besoin de templates. :-)
18/10/2011, 17h39
jblecanard

C'est aussi faisable avec de l'introspection.

Laurent Gomilla a écrit une lib d'introspection en C++, CAMP. Mais on dirait qu'il ne l'a maintient plus beaucoup :(
18/10/2011, 19h04
Joel F

Ou boost.fusion en adaptant ta structrure sous forme de fusion::map
18/10/2011, 19h45
screetch

Citation:

Envoyé par oodini

Si je fais ça, je n'ai plus besoin de templates. :-)

ben... les 95% utiliseront la version template générale et les 5% la version sécialisée...
je comprend pas le problème.

Je suis tout à fait d'accord avec screetch.

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
// Générique
template <typename T>
void doSpecificStuff(T* t)
{ ... }
 
// Spécialisation pour A
template <>
void doSpecificStuff(A* a)
{
    a->val1 = 5;
}
 
// Spécialisation pour B
template <>
void doSpecificStuff(B* b)
{
    b->val2 = 5;
}
 
(...)
 
 
// La fonction qui fait tout le boulot, du moins vu de l'extérieur
template <typename T>
void doStuff(T* t)
{
    (...) // Un bout des 95% de code générique
 
    doSpecificStuff(t); // Les 5% de code incriminés
 
    (...) // L'autre partie des 95% de code générique
}

... non ?

19/10/2011, 10h16
oodini

J'ai réfléchi au problème hier soir, et il ya effectivement peut-être moyen de m'en sortir par des spécialisations à des endroits rpécis de mon code. Je vous tiens au courant dans les prochains jours.
20/10/2011, 10h39
oodini

J'étais parti sur un template général, qui appelait en son sein un template spécialisé selon ce que je traite. Mais comme il y a dans l'histoire une boucle, ça m'oblige à faire des appels de template en boucle, et je ne pense pas que ça soit raisonnable en termes de temps d'exécution.
20/10/2011, 10h54
screetch

les template sont résolus a la compilation, ca ne coute rien a l'éxécution.

Bon, je vais expliciter un peu plus clairement mon problème, en le simplifiant grandement.

Pour l'instant, en gros, j'ai ça :

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
class A
{
    int membre_a;
};
 
class B
{
    int membre_b;
    float membre_c;
    double membre_d;
};
 
class C
{
    double membre_e;
    int membre_f;
};
 
void maFonction(A param)
{
    process(A.membre_a);
}
 
void maFonction(B param)
{
    process(B.membre_b);
    process(B.membre_c);
    process(B.membre_d);
}
 
void maFonction(C param)
{
    process(C.membre_e);
    process(C.membre_f);
}

J'aimerais avoir quelque chose du genre :

Code:

1
2
3
4
5
6
template <typename T>
maFonction(T param)
{
    pour chaque membre de T
        process(T.membre_?)
}

ou :

Code:

1
2
3
4
5
6
template <typename T>
maFonction(T param)
{
    pour certains membres de T
        process(T.membre_?)
}

20/10/2011, 16h22
jblecanard

Joel F a raison, ton use case est quasiment celui de la doc de Fusion si on regarde ceci puis ceci. Tu dois bien sûr écrire un BOOST_ADAPT_STRUCT pour chaque type, c'est ensuite réutilisable avec n'importe quel algo de fusion.

De toute façon, tu serais obligé d'instrumentaliser le code à un endroit ou un autre, car C++ ne fournit pas d'introspection.
20/10/2011, 16h52
oodini

Effectivement, je suis convaincu que Boost.Fusion serait la solution.

Malheureusement, il ne m'est pas possible de l'utiliser.
20/10/2011, 17h46
screetch

si tous tes types ont des members différents, tu vas sans doute galérer quelle que soit la solution.
Si comme tu le dis 95% des types utiliseront membre_a et seuls 5% utiliseront des membres spéciaux alors je n'ai toujours pas compris ce que tu as contre la spécialisation de template.

Dépendant de la taille du problème mais boost.fusion est l'artillerie lourde; plus configurable et plus générique (le type importe peu, pour peu qu'il ait soit membre_a, membre_b ou etc etc) mais c'est pas forcément ce dont tu as le plus besoin.

De plus on parle de combien de types la? 2? 10? 100?
20/10/2011, 18h09
oodini

Citation:

Envoyé par screetch

si tous tes types ont des members différents, tu vas sans doute galérer quelle que soit la solution.
Si comme tu le dis 95% des types utiliseront membre_a et seuls 5% utiliseront des membres spéciaux

Non. 95% du code n'est pas dépendant des membres des types, mais les 5% restants vont taper sur tous les membres de chaque type.

Citation:

Envoyé par screetch

De plus on parle de combien de types la? 2? 10? 100?

Ce que j'ai présenté est assez réaliste en termes de nombres de classes et de membres.
La principale différence est qu'il y a du code autour des appels à process(), et que cela se situe dans une boucle, car on bosse en fait sur les éléments d'un vecteur (qui est passé en paramètre à maFonction).