Discussion :

[Invité]

Bonsoir,

Il y a quelque chose que je ne saisis pas complètement. J'essaie de comprendre ce pattern mais rien n'y fait ..

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
class Createur
{
    public :
    virtual std::string getMarque() const=0;
    friend std::ostream &operator<<(std::ostream &o,const Createur *v)
    {
        return o << v->getMarque();
    }
    static Createur *createVoiture(std::string o);
};
        
        
        class CreateurConcretRenault : public Createur {
        public:
            std::string getMarque() const { return "Renault"; }
        };
        
        class CreateurConcretFiat : public Createur {
        public:
            std::string getMarque() const { return "Fiat"; }
        };

void f(const Createur *v)
        { std::cout << "Voiture " << v << std::endl; }
        
        Createur *Createur::createVoiture(std::string o)
        {
            if(o=="fr") return new CreateurConcretRenault();
            if(o=="it") return new CreateurConcretFiat();
            return 0;
        }

Code :

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

1
2
3
4
5
6
    int main()
    {
        Createur *v=Createur::createVoiture("it");
        f(v);
    
    return 0;}

1) En quoi dans ce code peut-on dire que la méthode createVoiture est une méthode de Fabrication ?
Serait-ce parce que on ne créer pas directement l'objet à partir d'un new mais à partir d'une méthode qui s'occupe de cela ?

2)Son utilisé, c'est donc pour être " plus efficace " ?

3)D'ailleurs dans le main , si on regarde bien , on ne voit plus le type concret ( on ne fait pas de new concret , du genre newRenaut,newFiat ) , serait-ce la raison ? Faire en sorte que le type concret n'apparait pas dans le main ?

4) Derniere question : J'ai vu que certains disaient que les méthodes statiques n'étaient pas un bon choix , et qu'il préférait créer un objet puis appliquer la méthode à cette instance. Mais comment faire cela sachant qu'on ne peut pas instancier une classe abstraite en c++ ?

[pseudocode]

D'ailleurs dans le main , si on regarde bien , on ne voit plus le type concret ( on ne fait pas de new concret , du genre newRenaut,newFiat ) , serait-ce la raison ? Faire en sorte que le type concret n'apparait pas dans le main ?

Oui, c'est cela. Ce pattern permet de découpler l'interface (type abstrait) et l'implémentation (type concret) d'un objet. La fabrique s'occupe de créer une instance "concrête" et de la renvoyer sous forme d'interface.

Dans ton cas, c'est même un pattern "Abstract Factory" car tu as aussi découplé l'interface et l'implémentation de la fabrique. Au final, ta fonction main() ne connait que l'interface de la fabrique et l'interface de l'objet.

[Invité]

Merci de ta réponse , ça m'aide beaucoup sachant que ce n'est pas toujours clair sur le net .

Par contre je sais pas si tu as vu mon édit, tu pourrais m'éclairer sur ma quatrième question ( et aussi sur la raison de faire cela ? ) ?

Du coup , tu dis que dans l'Abstract factory , on ne voit que l'interface et la fabrique de cette interface.
Que voit-on alors dans une Factory Method ?

[pseudocode]

Merci de ta réponse , ça m'aide beaucoup sachant que ce n'est pas toujours clair sur le net .

Par contre je sais pas si tu as vu mon édit, tu pourrais m'éclairer sur ma quatrième question ( et aussi sur la raison de faire cela ? ) ?

Si on utilise une méthode non-statique, il faut forcément instancier la classe de la fabrique. Donc on se retrouve couplé avec la classe concrête de la fabrique.

Si on veut absolument conserver le découplage de l'abstract factory, il faudrait instancier cette factory "avant", et passer son interface en argument de la fonction main().

Du coup , tu dis que dans l'Abstract factory , on ne voit que l'interface et la fabrique de cette interface.
Que voit-on alors dans une Factory Method ?

une Factory Method ce n'est pas un vrai pattern de conception. C'est une méthode qui crée une instance de classe et renvoie son interface.

C'est du découplage de "code", mais pas du découplage de "conception".

[Invité]

Raa je sais que je suis dur mais je n'ai toujours pas certaines réponses qui me bloque ..

1) Quand tu dis que c'est une Abstract Factory du fait que j'ai découplé l'interface et l'implémentation de la fabrique , c'est parce qu'on sait seulement que avec

Code :

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

Createur *v=Createur::createVoiture("it");

cela retourne un objet dont on ne connait pas le type concret mais l'on connait seulement son interface ?

Du coup , qu'est ce qu'il y aurait de plus pour qu'elle ne soit plus Abstract mais Factory tout court ?

2) L'utilité final tu dis est d'implémenter l'interface et l'implémentation. Mais je ne vois toujours pas l'utilisé ? A quoi bon ?

[pseudocode]

Raa je sais que je suis dur mais je n'ai toujours pas certaines réponses qui me bloque ..

1) Quand tu dis que c'est une Abstract Factory du fait que j'ai découplé l'interface et l'implémentation de la fabrique , c'est parce qu'on sait seulement que avec

Code :

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

Createur *v=Createur::createVoiture("it");

cela retourne un objet dont on ne connait pas le type concret mais l'on connait seulement son interface ?

Du coup , qu'est ce qu'il y aurait de plus pour qu'elle ne soit plus Abstract mais Factory tout court ?

hum... je vais essayer de simplifier ton exemple, car tes noms de classe sont un peu ambigus.

Code C++ :

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
main() {
  /* couplage interface / Implémentation */
  Voiture *v = new RenaultMegane();
  f(v);
}
 
main() {
  /* factory */
  Renault *renault = new Renault();
  Voiture *v = renault->createMegane();
  f(v);
}
 
main() {
  /* abstract factory */
  Constructeur *constructeur = new Renault();
  Voiture *v = constructeur->createVoiture("Megane");
  f(v);
}

2) L'utilité final tu dis est d'implémenter l'interface et l'implémentation. Mais je ne vois toujours pas l'utilisé ? A quoi bon ?

En reprenant mon exemple, ca permet de facilement créer de nouvelles classes concrètes sans trop impacter le code existant.

Code C++ :

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

1
2
3
4
5
main() {
  Constructeur *constructeur = new Mandataire("Renault", "Dacia", "Peugeot", "Citroen");
  Voiture *v = constructeur->createVoiture("Megane");
  f(v);
}

[Invité]

Tu es d'accord avec moi concernant Abstract Factory que ( selon mon premier exemple ) :

-On veut pouvoir créer des objets de différents types mais appartenant à une
même « famille ».
->C'est ce que l'on fait avec createVoiture qui elle , crée des objets de différents types d'une même famille ( voitureA , voitureB .. )

-La création doit pouvoir se faire au travers d'une seule et même classe (une usine de meuble abstraite)

-Les objets peuvent être créés par différentes classes (par exemple des usines des usines concrètes) qui chacune peuvent produire plusieurs types d'objets de la famille
-> ça c'est par exemple classe Createur , puis sous classe Voiture1,Voiture2 , puis encore sous classe Voiture1_modeleA,voiture1_modeleB etc .. ?

Les objets doivent pouvoir être manipulés sans que l'on ait besoin de savoir quelle classe (usine) les a créés
-> Hum ? C.A.D ?

[pseudocode]

Tu es d'accord avec moi concernant Abstract Factory que ( selon mon premier exemple ) :

-On veut pouvoir créer des objets de différents types mais appartenant à une
même « famille ».
->C'est ce que l'on fait avec createVoiture qui elle , crée des objets de différents types d'une même famille ( voitureA , voitureB .. )

Cette caractéristique n'est pas obligatoire pour une fabrique. On peut avoir une fabrique qui instancie toujours la même classe concrète, ou alors qui instancie des classes concrètes différentes.

-La création doit pouvoir se faire au travers d'une seule et même classe (une usine de meuble abstraite)

Oui. C'est la caractéristique particulière d'une fabrique abstraite.

-Les objets peuvent être créés par différentes classes (par exemple des usines des usines concrètes) qui chacune peuvent produire plusieurs types d'objets de la famille
-> ça c'est par exemple classe Createur , puis sous classe Voiture1,Voiture2 , puis encore sous classe Voiture1_modeleA,voiture1_modeleB etc .. ?

Idem, cette caractéristique n'est pas obligatoire pour une fabrique abstraite. Mais c'est tout de même l'intéret d'utiliser ce pattern.

Les objets doivent pouvoir être manipulés sans que l'on ait besoin de savoir quelle classe (usine) les a créés
-> Hum ? C.A.D ?

Oui. C'est la caractéristique générale d'une fabrique: elle renvoie une interface de l'objet, et pas son type concret.

[Invité]

Merci beaucoup, je comprends mieux tes exemples surtout la Abstract Factory qui elle ne montre que des interfaces.

Thanks you so much !