[Boost] :: DI créant des objets shared_ptr uniques à partir de l'injecteur

Question

En prenant cet exemple de code, je voudrais avoir comme résultat que button1 et button2 sont deux objets distincts.

#include <iostream> 
#include <memory> 
#include "di.hpp" 
namespace di = boost::di; 

struct CommandQueue { 
    void addCommand() {} 
}; 

struct Control { 
    Control(CommandQueue &cq) : cq(cq) { 
     static int sid{}; 
     id = ++sid; 
    } 

    CommandQueue& cq; 
    int id{}; 
}; 

int main() { 

    auto injector = di::make_injector(di::bind<CommandQueue>().in(di::singleton)); 

    auto button1 = injector.create<std::shared_ptr<Control>>(); 
    auto button2 = injector.create<std::shared_ptr<Control>>(); 

    std::cout << "button1->id = " << button1->id << std::endl; 
    std::cout << "button2->id = " << button2->id << std::endl; 

    return 0; 
} 

Le courant de sortie est la suivante:

button1-> id =

button2-> id =

Au lieu de la destinée:

button1-> id =

button2-> id =

Retrait du périmètre de vie di::singleton de CommandQueue singleton ne fixe pas aussi. Je sais que la portée à vie d'un shared_ptr est un singleton par défaut mais je pensais que c'était la dépendance injectée et non l'objet créé avec create.

Answer 1

En effet, la chose la plus simple pourrait être

auto button1 = injector.create<Control>(); 
auto button2 = injector.create<Control>(); 

std::cout << "button1.id = " << button1.id() << std::endl; 
std::cout << "button2.id = " << button2.id() << std::endl; 

Prints

button1.id = 1 
button2.id = 2 

---

Si vous doit avoir pointeurs partagés, la prochaine chose la plus simple serait

auto button1 = std::make_shared<Control>(injector.create<Control>()); 
auto button2 = std::make_shared<Control>(injector.create<Control>()); 

std::cout << "button1->id = " << button1->id() << std::endl; 
std::cout << "button2->id = " << button2->id() << std::endl; 

---

Conceptuellement vous voulez une usine de contrôle, pas un contrôle. Donc, vous devriez envisager de créer une usine à partir du conteneur de dépendance:

#include <boost/di.hpp> 
#include <iostream> 
#include <memory> 
namespace di = boost::di; 

struct CommandQueue { 
    void addCommand() {} 
}; 

struct Control { 
    Control(CommandQueue &cq) : _cq(cq), _id(idgen()) { } 

    int id() const { return _id; } 

    struct Factory { 
     Factory(CommandQueue& cq) : _cq(cq) {} 
     CommandQueue& _cq; 

     template <typename... Args> 
     auto operator()(Args&&... args) const { 
      return std::make_shared<Control>(_cq, std::forward<Args>(args)...); 
     } 
    }; 
    private: 
    static int idgen() { static int sid{}; return ++sid; } 
    CommandQueue &_cq; 
    int _id{}; 
}; 

int main() { 
    auto injector = di::make_injector(di::bind<CommandQueue>().in(di::singleton)); 

    auto factory = injector.create<Control::Factory>(); 
    auto button1 = factory(); 
    auto button2 = factory(); 

    std::cout << "button1->id = " << button1->id() << std::endl; 
    std::cout << "button2->id = " << button2->id() << std::endl; 
}