Python在C++項目中的依賴注入實踐

在C++項目中實踐依賴注入（Dependency Injection, DI）可以幫助我們更好地管理代碼之間的依賴關系，提高代碼的可測試性和可維護性。雖然Python和C++是兩種不同的編程語言，但我們可以在C++項目中借鑒Python的依賴注入實踐。以下是一些建議：

1. 使用接口和抽象類

在C++中，我們可以使用抽象基類（Abstract Base Class, ABC）來定義接口，這樣客戶端代碼就可以通過這些接口與具體實現進行交互，而不需要關心具體的實現細節。

// ILogger.h
#pragma once

class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void log(const std::string& message) = 0;
};

2. 使用智能指針管理對象生命周期

在C++中，我們可以使用智能指針（如std::shared_ptr和std::unique_ptr）來管理對象的生命周期，這樣可以避免內存泄漏和懸掛指針的問題。

#include <memory>

class FileLogger : public ILogger {
public:
    void log(const std::string& message) override {
        // 實現文件日志記錄
    }
};

class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        // 實現控制臺日志記錄
    }
};

3. 使用工廠模式創建對象

我們可以使用工廠模式來創建對象，這樣可以隱藏對象的創建細節，并且可以在不修改客戶端代碼的情況下更改對象的創建方式。

// LoggerFactory.h
#pragma once

#include <memory>

class ILogger;

class LoggerFactory {
public:
    static std::shared_ptr<ILogger> createLogger(const std::string& type);
};

// LoggerFactory.cpp
#include "LoggerFactory.h"
#include "FileLogger.h"
#include "ConsoleLogger.h"

std::shared_ptr<ILogger> LoggerFactory::createLogger(const std::string& type) {
    if (type == "file") {
        return std::make_shared<FileLogger>();
    } else if (type == "console") {
        return std::make_shared<ConsoleLogger>();
    }
    return nullptr;
}

4. 使用依賴注入容器

我們可以使用依賴注入容器來管理對象之間的依賴關系，這樣可以更方便地進行對象的創建和注入。

#include <memory>
#include <unordered_map>

class DependencyInjector {
public:
    template<typename T, typename... Args>
    std::shared_ptr<T> registerInstance(Args&&... args) {
        auto instance = std::make_shared<T>(std::forward<Args>(args)...);
        instances_[typeid(T).hash_code()] = instance;
        return instance;
    }

    template<typename T>
    std::shared_ptr<T> getInstance() {
        auto it = instances_.find(typeid(T).hash_code());
        if (it != instances_.end()) {
            return std::dynamic_pointer_cast<T>(it->second);
        }
        return nullptr;
    }

private:
    std::unordered_map<size_t, std::shared_ptr<void>> instances_;
};

5. 使用構造函數注入

在C++中，我們可以通過構造函數注入依賴關系，這樣可以確保對象在創建時就已經擁有了所需的依賴。

#include <memory>

class Application {
public:
    Application(std::shared_ptr<ILogger> logger) : logger_(logger) {}

    void run() {
        logger_->log("Application started.");
        // 其他邏輯
    }

private:
    std::shared_ptr<ILogger> logger_;
};

6. 使用示例

以下是一個完整的示例，展示了如何在C++項目中實踐依賴注入。

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>

// ILogger.h
#pragma once

class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void log(const std::string& message) = 0;
};

// FileLogger.h
#pragma once

#include "ILogger.h"

class FileLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "File: " << message << std::endl;
    }
};

// ConsoleLogger.h
#pragma once

#include "ILogger.h"

class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "Console: " << message << std::endl;
    }
};

// LoggerFactory.h
#pragma once

#include <memory>

class ILogger;

class LoggerFactory {
public:
    static std::shared_ptr<ILogger> createLogger(const std::string& type);
};

// LoggerFactory.cpp
#include "LoggerFactory.h"
#include "FileLogger.h"
#include "ConsoleLogger.h"

std::shared_ptr<ILogger> LoggerFactory::createLogger(const std::string& type) {
    if (type == "file") {
        return std::make_shared<FileLogger>();
    } else if (type == "console") {
        return std::make_shared<ConsoleLogger>();
    }
    return nullptr;
}

// DependencyInjector.h
#pragma once

#include <memory>
#include <unordered_map>

class DependencyInjector {
public:
    template<typename T, typename... Args>
    std::shared_ptr<T> registerInstance(Args&&... args) {
        auto instance = std::make_shared<T>(std::forward<Args>(args)...);
        instances_[typeid(T).hash_code()] = instance;
        return instance;
    }

    template<typename T>
    std::shared_ptr<T> getInstance() {
        auto it = instances_.find(typeid(T).hash_code());
        if (it != instances_.end()) {
            return std::dynamic_pointer_cast<T>(it->second);
        }
        return nullptr;
    }

private:
    std::unordered_map<size_t, std::shared_ptr<void>> instances_;
};

// Application.h
#pragma once

#include <memory>

class ILogger;

class Application {
public:
    Application(std::shared_ptr<ILogger> logger) : logger_(logger) {}

    void run() {
        logger_->log("Application started.");
        // 其他邏輯
    }

private:
    std::shared_ptr<ILogger> logger_;
};

// main.cpp
#include "Application.h"
#include "DependencyInjector.h"
#include "FileLogger.h"
#include "ConsoleLogger.h"
#include "LoggerFactory.h"

int main() {
    DependencyInjector injector;

    auto logger = LoggerFactory::createLogger("file");
    injector.registerInstance<ILogger>(logger);

    auto application = injector.getInstance<Application>();
    application->run();

    return 0;
}

通過以上步驟，我們可以在C++項目中實踐依賴注入，從而提高代碼的可測試性和可維護性。