Bonjours a tous,

j'ai crée les classes FactoryWidget et FactoryPage qui hérite de la classe Ifactory .

mon problème est que j'aimerai crée une liste de Ifactory .

j'aimerai faire un truc du style :

std::map<std::string ,Model::IFactory<T>> map;

map["page"] = new Model::Page::FactoryPage();
map["widget"] = new Model::Widget::FactoryWidget();

std::shared_ptr<Model::Page::IPage> page = map["page"]->Instentation("pageTelechargement");
std::shared_ptr<Model::Widget::IWidget> widget = map["Widget"]->Instentation("Widget");

les classe que j'ai : 

Ifactory :

namespace Model{
    template<typename Type>
    class IFactory {
    public:
        virtual Type Instentation(std::string name) = 0;
    private:
    };
}

FactoryWidget :

namespace Model {
    namespace Widget {
        class FactoryWidget : public Model::IFactory<std::shared_ptr<Model::Widget::IWidget>>{
        public:
            std::shared_ptr<Model::Widget::IWidget> Instentation(std::string name);
        protected :
            std::weak_ptr<Model::Widget::IWidget> imagePresentation;
            std::weak_ptr<Model::Widget::IWidget> listeActualite;
            std::weak_ptr<Model::Widget::IWidget> connexion;
        };
    }
}

FactoryPage :

namespace Model {
    namespace Page {
        class FactoryPage : public Model::IFactory<std::shared_ptr<Model::Page::IPage>>{
        public:
            FactoryPage();
            std::shared_ptr<Model::Page::IPage> Instentation(std::string name);
        protected:            
            std::weak_ptr<Model::Page::IPage> pageAccueil;
        };
    }
}

main.cpp

int main(int argc, char *argv[]) {
    
    Model::IFactory<std::shared_ptr<Model::Page::IPage>> *page= new Model::Page::FactoryPage();
    Model::IFactory<std::shared_ptr<Model::Widget::IWidget>> *widget= new Model::Widget::FactoryWidget();
}

merci d’avance pour votre aide .

Instentation ? Tu veux dire Instanciation, non ? Sinon, tu te prends pas mal la tête à faire des classes pour ça, utilise des lambda c'est plus simple. La fonction devrait retourner un unique_ptr et non pas un shared_ptr puisqu'à ce moment le pointeur n'est partagé par personne et je ne comprends pas à quoi servent le sweak_ptr.

#include <map>
#include <string>
#include <functional>

int main()
{
  std::map<std::string, std::function<std::unique_ptr<T>>> map{
    {"page", [](){
      ...
    }},
    {"widget", [](){
      ...
    }}
  };

  auto page = map["page"]("pageTelechargement");
  auto widget = map["Widget"]("Widget");
}

Mais tu ne pourras pas construire des pommes et des poires dans ta factory. Une factory construit un type prédéfini et toujours le même. Si tu veux un IPage alors il faut une factory qui te sort des IPage. Si tu veux des IWidget, alors il faut une seconde factory qui sort des IWidget.

Merci de ta réponse .

 oui Instanciation sait mieux .

non elle doit retourner un shared_ptr car il objet peut être utiliser pas plusieurs personne mais la factory a un sweak_ptr qui permet d'avoir une référence vers un shared_ptr sans l’incrémentée .

la factory crée l'objet si personne de l'utilise , si un objet est utiliser pas un autre objet il donne une référence et si plus personne ne l'utilise le shared_ptr se détruit .

shared_ptr<int> a = new int(); //1 instance
shared_ptr<int> b = a; //2 instance
sweak_ptr<int> c = b; // 2 instance
shared_ptr<int> d = c; // 3 instance

se que j'aimerai faire sait plutot avec une fonction ex :

shared_ptr<IWidget> widget = MegaFactory::Instanciation("widget")->Instanciation("widget1");
shared_ptr<Ipage> page = MegaFactory::Instanciation("page")->Instanciation("page telechargement");
shared_ptr<ChiffrageAsymétrique> chiffrage = MegaFactory::Instanciation("chiffrage")->Instanciation("RSA");

je pence que sait possible sait je ne sait plus comment faire .

-
Edité par di20 2 novembre 2018 à 11:16:41

Votre truc, c'est largement plus une Factory mais plus un "Holder".

Comme ça ressemble plus à grand-chose comme DP, ça sent pas bon votre "truc".

Pourquoi avoir une "MegaFactory" qui pue plutôt qu'un DP adapté dans chaque classe ?

Parce que là, c'est vraiment ajouter des fraises et des bananes?