高耦合指类直接创建并依赖具体实现，如UserService依赖DatabaseLogger，导致难以替换和测试；通过引入ILogger接口，使UserService依赖抽象，并通过构造函数注入具体实现，结合工厂模式创建对象，实现松耦合与可扩展性。
当C++项目中的类之间耦合度过高时，代码会变得难以测试、维护和扩展。一个常见的解决方案是引入依赖注入（Dependency Injection, DI），通过将对象的依赖关系从内部创建转移到外部传入，从而实现松耦合。
什么是类之间的高耦合？
高耦合通常表现为一个类直接创建并紧密依赖另一个具体类。例如：
class DatabaseLogger {
public:
void log(const std::string& msg) { /* 写入数据库 */ }
};
class UserService {
private:
DatabaseLogger logger; // 紧密依赖具体实现
public:
void addUser() {
// ...
logger.log("User added");
}
};
这样写的问题是：UserService 不仅依赖于 DatabaseLogger 的行为，还依赖其存在。如果想换成文件日志或控制台日志，就必须修改 UserService 的代码，违反了开闭原则。
使用接口抽象降低依赖
第一步是定义抽象接口，让高层模块依赖抽象而非具体实现。
立即学习“C++免费学习笔记（深入）”；
class ILogger {
public:
virtual ~ILogger() = default;
virtual void log(const std::string& msg) = 0;
};
class DatabaseLogger : public ILogger {
public:
void log(const std::string& msg) override {
std::cout << "[DB] " << msg << std::endl;
}
};
class FileLogger : public ILogger {
public:
void log(const std::string& msg) override {
std::cout << "[File] " << msg << std::endl;
}
};
现在，我们可以把具体的日志实现通过构造函数传入 UserService。
通过构造函数注入依赖
这是最常见、最清晰的依赖注入方式。
class UserService {
private:
ILogger* logger;
public:
explicit UserService(ILogger* logger) : logger(logger) {}
void addUser() {
// 业务逻辑...
logger->log("User added");
}};
使用时由外部决定传入哪种日志器：
int main() {
DatabaseLogger dbLogger;
FileLogger fileLogger;
UserService service1(&dbLogger); // 使用数据库日志
UserService service2(&fileLogger); // 使用文件日志
service1.addUser();
return 0;
}
此时 UserService 不再关心日志如何实现，只依赖抽象接口，耦合度显著降低。
结合工厂模式管理对象创建
随着对象增多，手动组装依赖会变得繁琐。可以用简单工厂来封装创建逻辑。
class LoggerFactory {
public:
static std::unique_ptr createLogger(LoggerType type) {
switch (type) {
case LoggerType::Database:
return std::make_unique();
case LoggerType::File:
return std::make_unique();
default:
throw std::invalid_argument("Unknown logger type");
}
}
};
这样在主程序中可以更灵活地配置：
auto logger = LoggerFactory::createLogger(LoggerType::File); UserService service(logger.get());
ype::File);
UserService service(logger.get());
基本上就这些。C++没有像 Java Spring 那样的自动 DI 框架，但通过接口抽象 + 构造函数注入 + 工厂模式，完全可以实现清晰的依赖管理。关键是让类依赖抽象，把“谁来创建依赖”这个问题交给更上层的模块处理。这样不仅降低了耦合，也让单元测试更容易——测试时可以注入模拟对象（Mock）。
