怎样实现C++的依赖注入 构造函数注入与接口注入实践

#include <iostream>
#include <string>

// 抽象的日志接口
class ILogger {
public:
    virtual void log(const std::string& message) = 0;
    virtual ~ILogger() = default;
};

// 一个简单的控制台日志实现
class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "Log: " << message << std::endl;
    }
};

// 需要日志服务的类
class UserService {
private:
    ILogger* logger;

public:
    // 构造函数注入
    UserService(ILogger* logger) : logger(logger) {}

    void registerUser(const std::string& username) {
        // ... 用户注册逻辑 ...
        logger->log("User registered: " + username);
    }
};

int main() {
    ConsoleLogger consoleLogger;
    UserService userService(&consoleLogger); // 注入 ConsoleLogger 实例
    userService.registerUser("Alice");

    return 0;
}

#include <iostream>
#include <string>

// 抽象的日志接口 (同上)
class ILogger {
public:
    virtual void log(const std::string& message) = 0;
    virtual ~ILogger() = default;
};

// 一个简单的控制台日志实现 (同上)
class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "Log: " << message << std::endl;
    }
};

// 定义一个注入接口
class ILoggable {
public:
    virtual void setLogger(ILogger* logger) = 0;
    virtual ~ILoggable() = default;
};

// 需要日志服务的类
class UserService : public ILoggable {
private:
    ILogger* logger;

public:
    UserService() : logger(nullptr) {}

    void setLogger(ILogger* logger) override {
        this->logger = logger;
    }

    void registerUser(const std::string& username) {
        // ... 用户注册逻辑 ...
        if (logger) {
            logger->log("User registered: " + username);
        } else {
            std::cerr << "Warning: Logger not set for UserService!" << std::endl;
        }
    }
};

int main() {
    ConsoleLogger consoleLogger;
    UserService userService;
    userService.setLogger(&consoleLogger); // 通过接口注入 ConsoleLogger 实例
    userService.registerUser("Bob");

    return 0;
}

#include <iostream>
#include <map>
#include <memory>
#include <typeindex>
#include <typeinfo>

class DIContainer {
public:
    template <typename T>
    void registerType(std::function<std::shared_ptr<T>()> factory) {
        typeFactories[typeid(T)] = [factory]() { return std::any(factory()); };
    }

    template <typename T>
    std::shared_ptr<T> resolve() {
        auto it = typeFactories.find(typeid(T));
        if (it != typeFactories.end()) {
            return std::any_cast<std::shared_ptr<T>>(it->second());
        }
        throw std::runtime_error("Type not registered: " + std::string(typeid(T).name()));
    }

private:
    std::map<std::type_index, std::function<std::any()>> typeFactories;
};

// 示例用法 (使用之前的 ILogger 和 UserService)

int main() {
    DIContainer container;

    // 注册类型
    container.registerType<ILogger>([]() { return std::make_shared<ConsoleLogger>(); });
    container.registerType<UserService>([&]() { return std::make_shared<UserService>(container.resolve<ILogger>().get()); });

    // 解析 UserService
    auto userService = container.resolve<UserService>();
    userService->registerUser("Charlie");

    return 0;
}