Discussion :

[nonozor]

Bonjour,

J'ai fait une classe qui contient des méthodes statiques, qui servent de services à d'autres classes.

Mon problème est que pour chacune de ces méthodes, j'ai fait des fonctions intermédiaires et des structs, qui ne servent jamais qu'à une seule fonction. Les grosses fonctions intermédiaires ont même des petites fonctions intermédiaires rien que pour elles!!!
Ca donne donc une déclaration de classe un peu bazare:

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
 
class ma_classe_de_service {
public:
    static A ();
    static B ();
    static C ();
 
private
// fonctions appelées par A
    static AA ();
    static AB ();
    static AC ();
// structure utilisée dans A
    struct A_A{
    }
// fonctions appelées par AA
    static AAA ();
    static AAB ();
// fonctions appelées par B
    static BA ();
    static BB ();
    static BC ();    
};

où Ai est une fonction appelée par A, AAi est une fonction appelée par AA, et ainsi de suite.

Est ce qu'il n'y aurait pas un moyen pour ranger à plus proprement?

[3DArchi]

Bonjour,
Une solution est de séparer les rôles : ta classe de service d'un côté et ses détails d'implémentation de l'autre :
ton_service.h :

Code :

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

1
2
3
4
5
6
class ma_classe_de_service {
public:
    static A ();
    static B ();
    static C ();
};

Ensuite tu définis des classes pour tes implémentations :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
struct A_Impl
{
// fonctions appelées par A
    void AA ();
    void AB ();
    void AC ();
// structure utilisée dans A
    struct A_A{
    }
// eventuellement un contexte :
};

Et tu l'utilises dans l'implémentation ton_service.cpp :

Code :

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

1
2
3
4
5
6
7
void ma_classe_de_service::A ()
{
   A_Impl impl(/*param si besoin*/);
   impl.AA();
   impl.AB();
   impl.AC();
}

Ce découpage te permettra en outre de faire évoluer ton implémentation plus facilement : si seul A_Impl change, pas besoin de tout recompiler. Ou encore de faire de A_Impl une classe abstraite dont la classe concrète est instancié selon des paramètres spécifiques. Ou templatiser ma_classe_de_service::A pour lui fournir la class A_Impl à utiliser. Toutes ces techniques accroissent la souplesse et l'évolutivité de ton service.