Discussion :

[Grasshoper]

Bonsoir à toutes et à tous,

J'ai un petit problème d'architecture, sans doute très simple à résoudre: j'ai une classe mère et une classe fille et chacune d'elles instancient un objet.
Mais ces objets diffèrent suivant que ce soit la classe mère ou la classe fille qui les instancie, exemple:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//**************** Base Class ****************
class Base {
public:
    Base(int a1, int a2, int a3)
    :a{a1}, b{a2}, c{a3}
    {
        L = new Autre_Base(a1, a2);
    };
    ~Base() {
        delete L;
    };
protected:
    int a, b, c;
private:
    Autre_Base * L;
};
 
//**************** Derived Class ****************
class Derived: public Base{
public:
    Derived(int a1, int a2, int a3)
    :Base(a1, a2, a3)
    {
        L = new Autre_Derived(a1, a3);
    };
    ~Base() {};
private:
    Autre_derived * L;
};
 
//**************** Autre_Base Class ****************
class Autre_Base {
public:
    Autre_Base(int a1, int b1)
    :a{a1}, b{b1}
    {};
    ~Autre_Base() {};
protected:
    int a, b;
};
 
//**************** Autre_Derived Class ****************
class Autre_Derived: public Autre_Base {
public:
    Autre_Derived(int a1, int b1)
    :Autre_Base(a1, b1)
    {};
    ~Autre_Derived() {};
};

Je n'ai pas détaillé plus, mais des fonctions sont présentes dans Autre_Base et Autre_derived qui effectuent des calculs similaires mais avec des différences fondamentales.
D'autre part, si j'appelle le constructeur de 'Derived' qui appelle celui de la 'Base', l'objet 'L' est instancié 2 fois (une fois dans la Base et une fois dans la Derived)
Comment arranger cette structure (dois-je passer par une classe pure virtuelle?). Sachant que cette structure est légère mais instanciée intensivement (de l'ordre de 10^11 ou 10^12 fois environ).

Merci beaucoup pour vos conseils éclairés!

[foetus]

On sent un "code smell" (lien wiki en français et anglais)

Il me semble que pour faire ce que tu veux faire, il faut faire une fonction virtuelle, une fonction

1. que tu appelles dans le constructeur de la classe mère
2. que tu mets les spécificités de chaque classe

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
36
//**************** Base Class ****************
class Base {
public:
    Base(int a1, int a2, int a3) : a{a1}, b{a2}, c{a3} {
        specific_init();
    }
    ~Base() {
        delete L;
    }
 
protected:
    virtual void specific_init() {
        L = new Autre_Base(a1, a2);
    }
 
protected:
    int a, b, c;
 
private:
    Autre_Base * L;
};
 
//**************** Derived Class ****************
class Derived: public Base{
public:
    Derived(int a1, int a2, int a3) : Base(a1, a2, a3) {}
    ~Base() {}
 
protected:
    virtual void specific_init() {
        L = new Autre_Derived(a1, a3);
    }
 
private:
    Autre_derived * L;
};

Édit 1 : En C++, on ne peut pas appeler une fonction virtuelle dans le constructeur
Ah flûte
Il faut passer par des templates pour appeler cette fonction Et même mieux pour passer le type de l'objet

Édit 2 : À la place des templates, je pense qu'on peut utiliser des injections de dépendances (<- lien wiki en anglais, mais en gros on passe l'objet soit au constructeur soit à l'appel du traitement)
Et au vu de mon code, peut-être que l'héritage n'est plus nécessaire

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
typedef Autre_Base* (*t_specific_init) (int, int, int); // maybe useless parameters
 
//**************** Base Class ****************
template <typename T, t_specific_init specific_init>
class Base {
public:
    Base(int a1, int a2, int a3) : a{a1}, b{a2}, c{a3} {
        L = specific_init(a1, a2, a3);
    }
    ~Base() {
        delete L;
    }
 
protected:
    int a, b, c;
 
private:
    T* L;
};
 
//**************** Derived Class ****************
template <typename T, t_specific_init specific_init>
class Derived: public Base<T, specific_init> {
public:
    Derived(int a1, int a2, int a3) : Base(a1, a2, a3) {}
    ~Base() {}
};

[PadawanDuDelphi]

Bonjour,

A mon avis le problème doit pouvoir être résolu avec un design pattern plus adaptée.

Le premier qui me vient en tête, c'est une Factory: https://en.wikipedia.org/wiki/Factory_method_pattern
Tu as un ensemble d'objets manipulés de la même manière mais de types différents.

En règle général, si dans ton code tu as multiplies les "if" et les cast dans une méthode ou une classe, c'est que tu as plusieurs méthodes/objets disctincts.

++.