Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Design Patterns Discussion :

Compréhension Pattern Factory Method


Sujet :

Design Patterns

  1. #1
    Invité
    Invité(e)
    Par défaut Compréhension Pattern Factory Method
    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++ ?
    Dernière modification par Invité ; 27/07/2013 à 01h29.

  2. #2
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 061
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 061
    Points : 15 766
    Points
    15 766
    Par défaut
    Citation Envoyé par tchoumo Voir le message
    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.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  3. #3
    Invité
    Invité(e)
    Par défaut
    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 ?

  4. #4
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 061
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 061
    Points : 15 766
    Points
    15 766
    Par défaut
    Citation Envoyé par tchoumo Voir le message
    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".
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  5. #5
    Invité
    Invité(e)
    Par défaut
    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 ?

  6. #6
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 061
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 061
    Points : 15 766
    Points
    15 766
    Par défaut
    Citation Envoyé par tchoumo Voir le message
    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);
    }
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  7. #7
    Invité
    Invité(e)
    Par défaut
    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 ?
    Dernière modification par Invité ; 27/07/2013 à 04h12.

  8. #8
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 061
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 061
    Points : 15 766
    Points
    15 766
    Par défaut
    Citation Envoyé par tchoumo Voir le message
    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.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  9. #9
    Invité
    Invité(e)
    Par défaut
    Merci beaucoup, je comprends mieux tes exemples surtout la Abstract Factory qui elle ne montre que des interfaces.

    Thanks you so much !

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Fabrique] [Java] Design Pattern Factory
    Par SkyBioSS dans le forum Design Patterns
    Réponses: 3
    Dernier message: 24/05/2006, 14h53
  2. Réponses: 11
    Dernier message: 03/05/2006, 15h12
  3. Spring et factory-method
    Par dehbi dans le forum Spring
    Réponses: 3
    Dernier message: 31/03/2006, 16h00
  4. factory method
    Par mencaglia dans le forum C++
    Réponses: 2
    Dernier message: 31/01/2006, 09h02
  5. [GOF] Abstract Factory vs Factory Method
    Par Greybird dans le forum Design Patterns
    Réponses: 3
    Dernier message: 10/06/2005, 22h42

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo