答案：c++依赖注入容器通过模板和可变参数实现类型注册与依赖解析。支持构造函数注入和单例管理，利用type_index映射接口与实现，结合lambda创建实例，实现控制反转。
依赖注入（Dependency Injection, DI）是一种设计模式，用于解耦组件之间的依赖关系。在C++中，虽然没有像C#或Java那样的运行时反射机制，但我们依然可以通过模板、工厂模式和注册表的方式实现一个轻量级的依赖注入容器。
基本设计思路
DI容器的核心是管理对象的生命周期和依赖关系。我们需要做到：
- 注册类型与其实现的映射关系
- 按需创建实例（单例或瞬时）
- 自动解析构造函数参数中的依赖
由于C++缺乏运行时类型信息（RTTI）支持，我们通过模板来静态绑定类型，结合可变参数模板处理构造函数参数。
接口定义与注册机制
首先定义一个简单的容器类，支持将接口与实现绑定：
立即学习“C++免费学习笔记（深入）”；
class container {
private:
std::map<std::type_index, std::function<void*()>> registry;
<p>public:
template <typename Interface, typename Implementation>
void register_type() {
registry[std::type_index(typeid(Interface))] = []() -> void* {
return new Implementation();
};
}</p><pre class='brush:php;toolbar:false;'>template <typename T>
T* resolve() {
auto it = registry.find(std::type_index(typeid(T)));
if (it == registry.end()) return nullptr;
return static_cast<T*>(it->second());
}};
这个版本是最基础的，只能注册无参构造的对象。但实际使用中，对象往往需要依赖其他服务。
支持构造函数注入
为了支持带参数的构造函数，我们可以利用可变参数模板递归解析依赖：
template <typename T, typename... Args>
T* create_instance() {
return new T(resolve<Args>()...);
}
然后在注册时传入构造器函数：
template <typename Interface, typename Implementation, typename... Dependencies>
void register_type_with_deps() {
registry[std::type_index(typeid(Interface))] = [this]() -> void* {
return create_instance<Implementation, Dependencies...>();
};
}
这样就能自动解析构造函数中声明的依赖项。
生命周期管理：单例 vs 瞬时
很多服务应作为单例存在。我们可以通过包装注册逻辑来支持不同生命周期：
- **瞬时模式**：每次调用resolve都创建新实例
- **单例模式**：首次创建后缓存实例，后续返回同一对象
修改注册方式：
template <typename Interface, typename Implementation, typename... Deps>
void register_singleton() {
Implementation* instance = nullptr;
registry[std::type_index(typeid(Interface))] = [this, &instance]() -> void* {
if (!instance) {
instance = create_instance<Implementation, Deps...>();
}
return instance;
};
}
注意这里使用了引用捕获，确保instance在lambda中持久存在。
使用示例
假设我们有两个服务：
struct ILogger {
virtual void log(const std::string& msg) = 0;
virtual ~ILogger() = default;
};
<p>struct ConsoleLogger : ILogger {
void log(const std::string& msg) override {
std::cout << "[LOG] " << msg << std::endl;
}
};</p><p>struct UserService {
ILogger<em> logger;
UserService(ILogger</em> l) : logger(l) {}
void do_work() { logger->log("work done"); }
};</p>使用容器：
container c; c.register_singleton<ILogger, ConsoleLogger>(); c.register_type_with_deps<UserService, UserService, ILogger>(); <p>auto user_service = c.resolve<UserService>(); user_service->do_work(); // 输出: [LOG] work done</p>
基本上就这些。一个简单的C++依赖注入容器可以通过模板+函数对象+类型索引实现，虽不如高级语言灵活，但在大多数场景下足够使用。关键是理解其背后“控制反转”和“依赖解耦”的思想。
