Discussion :

[oodini]

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 :

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

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.

[screetch]

ca s'appelle la spécialisation.

Code :

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

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; }

[oodini]

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

[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

[Joel F]

Ou boost.fusion en adaptant ta structrure sous forme de fusion::map

[screetch]

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.

[Steph_ng8]

Je suis tout à fait d'accord avec screetch.

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
// 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 ?

[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.

[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.

[screetch]

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

[oodini]

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

Pour l'instant, en gros, j'ai ç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
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 :

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

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

ou :

Code :

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

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

[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.

[oodini]

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

Malheureusement, il ne m'est pas possible de l'utiliser.

[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?

[oodini]

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.

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).