Gérer plusieurs implémentations d'une méthode

Version imprimable

Bonjour à tous,

J'ai créé une classe dont deux méthodes ont 2 implémentations chacune. Je souhaiterais comparer l'efficacité des ces 2x2 implémentations.
Comment faire pour qu'il soit facile de passer d'une implémentation à l'autre?

Actuellement, je passe en paramètre de ma classe deux entiers prenant les valeurs 1 ou 2 pour sélectionner l'implémentation:

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <iostream>
 
class My_class {
public:
    My_class(int implem_func1, int implem_func2);
    int func1();
    int func2();
 
private:
    const int implem_func1;
    const int implem_func2;
    int func1_implem1();
    int func1_implem2();
    int func2_implem1();
    int func2_implem2();
};
 
 
My_class::My_class(int implem_func1, int implem_func2): implem_func1(implem_func1), implem_func2(implem_func2) {}
 
///////////////////////////////////////
// Definition de la premiere methode //
///////////////////////////////////////
int My_class::func1_implem1() {
    return 2+2;
}
 
int My_class::func1_implem2() {
    return 2*2;
}
 
int My_class::func1() {
    if (implem_func1 == 1) {
	return func1_implem1();
    }
    else {
	return func1_implem2();
    }
}
 
///////////////////////////////////////
// Definition de la deuxieme methode //
///////////////////////////////////////
int My_class::func2_implem1() {
    return 4*3;
}
 
int My_class::func2_implem2() {
    return 4+4+4;
}
 
int My_class::func2() {
    if (implem_func2 == 1) {
	return func2_implem1();
    }
    else {
	return func2_implem2();
    }
}
 
int main() {
    My_class my_class11(1,1);
    std::cout << my_class11.func1() << std::endl;
    std::cout << my_class11.func2() << std::endl;
    My_class my_class12(1,2);
    std::cout << my_class12.func1() << std::endl;
    std::cout << my_class12.func2() << std::endl;
    My_class my_class21(2,1);
    std::cout << my_class21.func1() << std::endl;
    std::cout << my_class21.func2() << std::endl;
    My_class my_class22(2,2);
    std::cout << my_class22.func1() << std::endl;
    std::cout << my_class22.func2() << std::endl;
    return 0;
}

Les valeurs des paramètres implem_func1 et implem_func2 étant testées à chaque appel des fonctions func1 et func2, cette solution ne me parait pas satisfaisante.
Qu'en pensez vous?
Merci

13/01/2019, 16h26
Bousk

Salut,

tu pourrais le faire sous forme de foncteur par exemple.
Mais en terme de performance, l'idéal serait que ce soit décidé à la compilation.
13/01/2019, 18h27
foetus

Tu peux essayer le patron de conception stratégie (<- lien wiki en français)
14/01/2019, 01h11
Luc Hermitte

+1 pour faire ça à la conception. Prévoir 2 politiques dans une classe (template). Chaque politique s'occupant de choisir l'implémentation d'une des 2 fonctions.
Avec, passer les 4 instanciations templates possibles à google.benchmark.

La difficulté: extraire les politiques des classes originales. Cela peut être complexe s'il y a beaucoup de dépendances à des membres "partagés" avec d'autres fonctions membres.
14/01/2019, 02h20
Pyramidev
Bonjour,

Attention, pour les tests, si tes fonctions funcX_implemY ont un temps d'exécution très très court, alors la performance de leur code dépendra du contexte dans lequel elles seront appelées.
Pour plus de détails, voir l'article : The wrong way of benchmarking the most efficient integer comparison function.
Alors, une solution fiable serait de faire de la compilation conditionnelle avec le préprocesseur (avec #if ou #ifdef), de compiler le programme pour chacune des versions et de lancer un script qui compare les temps d'exécution.

Par contre, si les fonctions funcX_implemY sont suffisamment lentes pour que le contexte appelant n'ait pas d'impact sur les performances, alors tu peux faire ce que tu veux. Remarque : si tu fais de l'inversion des dépendances, alors tu pourras plus facilement ajouter de nouvelles implémentations.

Exemples d'inversion des dépendances :
- Patron de conception stratégie (cité par foetus) : la classe My_class stocke deux références vers des classes de base. Les implémentations des funcX_implemY sont dans les classes dérivées.
- Classes de politique (citées par Luc Hermitte) : My_class devient un template avec deux paramètres. Les deux arguments du template sont des types dont une des opérations implémente une des fonctions funcX_implemY.
- La classe My_class stocke deux std::function (cas particulier des foncteurs cités par Bousk).

Bonjour à tous,

Merci pour vos réponses.
J'ai implémenté ça avec de la compilation conditionnelle

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
50
51
52
53
54
55
56
57
#define IMPLEM_FUNC1 1
#define IMPLEM_FUNC2 1
#include <iostream>
 
class My_class {
public:
    My_class();
    int func1();
    int func2();
};
 
My_class::My_class(){}
 
///////////////////////////////////////
// Definition de la premiere methode //
///////////////////////////////////////
 
#if IMPLEM_FUNC1==1
 
int My_class::func1() {
    return 2+2;
}
 
#elif IMPLEM_FUNC1==2
 
int My_class::func1() {
    return 2*2;
}
 
#endif
 
///////////////////////////////////////
// Definition de la deuxieme methode //
///////////////////////////////////////
 
#if IMPLEM_FUNC2==1
 
int My_class::func2() {
    return 4*3;
}
 
#elif IMPLEM_FUNC2==2
 
int My_class::func2() {
    return 4+4+4;
}
 
#endif
 
///////////////////////////////////////
 
int main() {
    My_class my_class;
    std::cout << my_class.func1() << std::endl;
    std::cout << my_class.func2() << std::endl;
    return 0;
}

J'ai l'impression que ça fait un peu "bidouillage" mais je vais me contenter de ça pour l'instant et essayer de comprendre comment fonctionnent vos autres solutions.