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

class ctor { public: explicit ctor(int i) : i(i) {} int i; }; struct aggregate { double d; }; class example { example(aggregate a, const ctor& c) { assert(87.0 == a.d); assert(42 == c.i); }; }; int main() { const auto injector = di::make_injector( di::bind<int>.to(42), di::bind<double>.to(87.0) ); injector.create<example>(); }

struct interface { virtual ~iworld() noexcept = default; virtual int get() const = 0; }; class implementation : public interface { public: int get() const override { return 42; } }; struct example { example(std::shared_ptr<interface> i) { assert(42 == i->get()); } }; int main() { const auto injector = di::make_injector( di::bind<interface>.to<implementation>() ); injector.create<std::unique_ptr<example>>(); }

template<class TPolicy = class TErrorPolicy> class simple_updater : TPolicy { void update() { TPolicy::on("update"); } }; template<class T = class TUpdater> class example { public: explicit example(const TUpdater& updater) : updater(updater) { } void update() { updater.update(); } private: const TUpdater& updater; }; int main() { struct throw_policy { void on(std::string_view str) { throw std::runtime_error(str); } }; const auto injector = di::make_injector( di::bind<class TErrorPolicy>.to<throw_policy>(), di::bind<class TUpdater>.to<simple_updater>() ); injector.create<example>().update(); }

struct Streamable { template<class T> auto requires(T&& t) -> decltype( int( t.read() ), t.write(int) ); }; template<class Exchange = Streamable(class ExchangeStream) class Engine = Streamable(class EngineStream)> class example { example(Exchange exchange, Engine engine) : exchange(exchange), engine(engine) { } }; int main() { const auto injector = di::make_injector( di::bind<Streamable(class ExchangeStream)>.to<exchange>(), di::bind<Streamable(class EngineStream)>.to<engine>() ); injector.create<example>(); }