c++如何实现一个简单的依赖注入容器_c++控制反转(IoC)原理

#include <map>
#include <functional>
#include <typeindex>
#include <memory>

class Container {
public:
    template<typename Interface, typename Implementation>
    void Register() {
        creators[std::type_index(typeid(Interface))] = []() {
            return std::make_shared<Implementation>();
        };
    }

    template<typename T>
    std::shared_ptr<T> Resolve() {
        auto it = creators.find(std::type_index(typeid(T)));
        if (it == creators.end()) {
            return nullptr; // 未注册
        }
        return std::static_pointer_cast<T>(it->second());
    }

private:
    std::map<std::type_index, std::function<std::shared_ptr<void>()>> creators;
};

struct ILogger {
    virtual void log(const std::string& msg) = 0;
    virtual ~ILogger() = default;
};

struct ConsoleLogger : ILogger {
    void log(const std::string& msg) override {
        std::cout << "[LOG] " << msg << std::endl;
    }
};

struct FileLogger : ILogger {
    void log(const std::string& msg) override {
        std::cout << "[FILE] " << msg << std::endl; // 简化模拟
    }
};

struct MyService {
    std::shared_ptr<ILogger> logger;
    MyService(std::shared_ptr<ILogger> l) : logger(l) {}

    void doWork() {
        logger->log("Doing work...");
    }
};

int main() {
    Container container;
    container.Register<ILogger, ConsoleLogger>();  // 绑定接口到实现
    container.Register<MyService, MyService>();     // 自注册

    auto service = container.Resolve<MyService>();
    if (service) {
        service->doWork();
    }
    return 0;
}

[LOG] Doing work...

container.Register<MyService>([&]() {
    return std::make_shared<MyService>(container.Resolve<ILogger>());
});