Bonjour,

De ce que j'ai compris de ce pattern , c'est qu'il permet de créer des objets complexes à partir d'autres objets , c'est en quelque sorte une construction incrémentale .
En gros , on assemble plusieurs objets pour les monter et n'en faire qu'un ( Tour de PC , un Menu , etc ..)

Du coup , il y avait certaines classes correspondant à des notions qui tel que je l'ai compris :

Directeur : C'est lui qui va utiliser la méthode du Builder

Builder/Monteur : C'est lui qui définit l'interface des méthodes utilises à l'assemblage/construction de l'objet complexe

ConcreteBuilder/Monteur : S'occupe d'assembler les composants de l'objet complexe

Produit : L'objet complexe

J'aimerais avoir la confirmation que dans ce programme c++ ci-dessous , tel classe correspond bien à tel notion :

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
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
class Voiture /* L'objet complexe */
{

private:
    std::string portiere;
    std::string siege;
    
public:
    void setPortiere(std::string p);
    void setSiege(std::string s);
    friend std::ostream &operator<<(std::ostream &o,const Voiture *v);
};


void Voiture::setPortiere(std::string p) {  portiere=p; }

void Voiture::setSiege(std::string s)  { siege=s; }

std::ostream &operator<<(std::ostream &o,const Voiture *v)
{
    return o << "Portière en " << v->portiere << " et signe en " << v->siege;
}

class MonteurVoiture /* Le monteur/builder : définit l'interface des méthodes utiles à l'assemblage de l'objet */
{
    
protected:
    Voiture *v;
    
public:
    void createVoiture();
    Voiture *getVoiture();
    virtual void addPortiere() =0;
    virtual void addSiege() =0;
    static MonteurVoiture* instanceVoiture(std::string type);
    
};

void MonteurVoiture::createVoiture()
{
    v=new Voiture();
}

Voiture* MonteurVoiture::getVoiture() { return v; }


class MonteurVoitureLuxe : public MonteurVoiture /* ConcreteBuilder  : va assembler les différents composants de l'objet */
{
    
public:
    void addPortiere();
    void addSiege();
    
};

void MonteurVoitureLuxe::addPortiere() { v->setPortiere("Acier blindé"); }
void MonteurVoitureLuxe::addSiege() { v->setSiege("Cuir"); }

class MonteurVoitureOrdinaire : public MonteurVoiture /* ConcreteBuilder  : va assembler les différents composants de l'objet */

{
    
public:
    void addPortiere();
    void addSiege();
    
};

void MonteurVoitureOrdinaire::addPortiere() { v->setPortiere("Tôle"); }
void MonteurVoitureOrdinaire::addSiege() { v->setSiege("Tissu"); }


class Atelier /* Director qui va executer les méthodes du monteur */
{
    
private:
    MonteurVoiture *monteur;
    
public:
    Atelier(MonteurVoiture *m) { monteur=m; }
    Voiture *doTheJob();
};

Voiture* Atelier::doTheJob()
{
    monteur->createVoiture();
    monteur->addPortiere();
    monteur->addSiege();
    return monteur->getVoiture();
}

    MonteurVoiture* MonteurVoiture::instanceVoiture(std::string type)
    {
        if(type=="luxe") return new MonteurVoitureLuxe();
        else return new MonteurVoitureOrdinaire();
    }
main.cpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
using namespace std;
#include "Voiture.h"

int main()
{
    
    MonteurVoiture *m=MonteurVoiture::instanceVoiture("luxe");
    Atelier a(m);
    cout << a.doTheJob() << endl;
    return 0;
    
}
Du coup , en général , les étapes ressembles à tel qu'il est décrit dans le tutoriel :

-On instancie un Monteur/Builder
-On le fournit au directeur..
-..qui lui va executer les méthodes du builder.

Merci d'avance à ceux qui me renseigneront.