c++如何实现一个简单的依赖注入(DI)容器_c++控制反转(IoC)设计【架构】

C++轻量级DI容器通过控制反转将对象创建与依赖管理交由外部容器处理，基于C++17+实现，强调接口与实现分离、依赖抽象而非具体。

c++如何实现一个简单的依赖注入(di)容器_c++控制反转(ioc)设计【架构】

在 C++ 中实现一个轻量级依赖注入（DI）容器，核心是把对象的创建和依赖关系的管理从类内部抽离出来，交由外部容器统一控制——这就是控制反转（IoC）的本质。它不依赖框架，用标准 C++17+ 就能写出清晰、可测试、松耦合的结构。

一、明确接口与实现分离（面向抽象编程）

DI 的前提是“依赖于抽象，而非具体”。先定义接口（纯虚类），再提供具体实现：

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

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

struct FileLogger : ILogger {
    std::string filename;
    FileLogger(const std::string& f) : filename(f) {}
    void log(const std::string& msg) override {
        std::ofstream out(filename, std::ios::app);
        out << "[FILE] " << msg << "\n";
    }
};

二、设计一个简易 DI 容器（支持单例/瞬态/工厂注册）

容器本质是一个类型到创建逻辑的映射表。用 std::unordered_map + std::function + std::any（或类型擦除）即可支撑多态注册。以下是最小可行版本（无线程安全，适合学习）：

class DIContainer {
private:
    std::unordered_map<std::type_index, std::function<std::any()> > creators;
    std::unordered_map<std::type_index, std::any> instances; // 单例缓存

public:
    template<typename T, typename Impl = T>
    void register_type() {
        creators[std::type_index(typeid(T))] = []() -> std::any {
            return std::make_unique<Impl>();
        };
    }

    template<typename T>
    void register_instance(std::unique_ptr<T> instance) {
        instances[std::type_index(typeid(T))] = std::move(instance);
        creators.erase(std::type_index(typeid(T))); // 优先走实例
    }

    template<typename T>
    std::unique_ptr<T> resolve() {
        auto type_idx = std::type_index(typeid(T));
        if (instances.find(type_idx) != instances.end()) {
            return std::any_cast<std::unique_ptr<T>>(instances[type_idx]);
        }
        if (creators.find(type_idx) != creators.end()) {
            auto obj = creators[type_idx]();
            return std::any_cast<std::unique_ptr<T>>(obj);
        }
        throw std::runtime_error("Type not registered: " + std::string(typeid(T).name()));
    }
};

三、支持构造函数注入（手动传递依赖）

C++ 没有反射，无法自动解析构造参数，所以需显式注册带依赖的工厂函数。这是最实用、最可控的方式：

Procys

AI驱动的发票数据处理

102 查看详情 Procys

让容器知道 “如何用 ILogger 构建 Service”
注册时捕获已解析的依赖（如 logger），绑定为 lambda
避免模板爆炸，也利于单元测试替换 mock

// 假设服务依赖 ILogger
struct Service {
    std::unique_ptr<ILogger> logger;
    Service(std::unique_ptr<ILogger> l) : logger(std::move(l)) {}
    void do_work() { logger->log("working..."); }
};

// 注册方式：显式声明依赖
container.register_type<ILogger, ConsoleLogger>(); // 先注册 ILogger 实现

container.creators[std::type_index(typeid(Service))] = [&container]() -> std::any {
    auto logger = container.resolve<ILogger>();
    return std::make_unique<Service>(std::move(logger));
};

四、使用示例：组合即配置

主程序不再 new 对象，只跟容器打交道；切换实现只需改注册，不碰业务代码：

int main() {
    DIContainer container;

    // 方式1：绑定具体实现（ConsoleLogger）
    container.register_type<ILogger, ConsoleLogger>();

    // 方式2：或换为文件日志（一行切换）
    // container.register_instance(std::make_unique<FileLogger>("app.log"));

    // 注册 Service（含依赖解析逻辑）
    container.creators[std::type_index(typeid(Service))] = [&container]() -> std::any {
        auto logger = container.resolve<ILogger>();
        return std::make_unique<Service>(std::move(logger));
    };

    // 使用
    auto svc = container.resolve<Service>();
    svc->do_work(); // 输出 [LOG] working...

    return 0;
}

基本上就这些。不需要宏、不依赖第三方，靠类型擦除 + 函数对象 + RAII 就能落地。关键不是“全自动”，而是“谁负责创建、谁负责连接”变得清晰可管理。真实项目中可在此基础上加作用域（transient/scoped/singleton）、生命周期钩子、模块化注册（Module 类）、或对接 Boost.DI / Dice 等成熟库。但原理始终一致：把 new 和 new 的顺序，交给容器说了算。

以上就是c++++如何实现一个简单的依赖注入(DI)容器_c++控制反转(IoC)设计【架构】的详细内容，更多请关注其它相关文章！

# 前向 # 宿州关键词排名推广 # 三水短视频关键词排名 # 抖音搜索seo脑图 # 整体推广营销方案 # 苹果线下营销推广方案 # 电扇品牌营销推广 # 酒店网站建设开发流程 # 塔城seo排名 # 抖音营销推广文案图片 # 佛山搜狗seo哪家专业 # c++ # 游戏开发 # 如何处理 # 尼克 # 多态 # 而非 # 就能 # 如何用 # 递归 # 如何实现 # 依赖注入

返回目录在线咨询

上一篇：C++内联函数是什么_C++ inline使用风险与规则
下一篇：HTML5如何连接jquery_HTML5连接jquery方法教程【快速上手】

您的项目需求