c++面试11_什么是高内聚低耦合

🧩 一、核心概念

概念	含义	理想状态
内聚（Cohesion）	模块内部功能之间的关联程度	一个模块只做一类事情（单一职责）
耦合（Coupling）	模块之间的依赖程度	模块之间相互独立，接口清晰、依赖最小

简言之：

高内聚 → 模块内部紧密合作
低耦合 → 模块之间松散关联

⚙️ 二、设计原则（必须掌握）

1. 单一职责原则 (SRP)

   每个模块或类只负责一项功能。

   • ✅ 好：Logger 只负责日志，不负责打印格式。

   • ❌ 坏：一个 Utils 里什么工具函数都有。

2. 开闭原则 (OCP)

   对扩展开放，对修改关闭。

   → 使用接口、多态、配置等方式扩展功能，而不是改老代码。

3. 依赖倒置原则 (DIP)

   高层模块不依赖低层模块，两者都依赖抽象。

   → 用接口代替具体实现。

4. 接口隔离原则 (ISP)

   一个接口不应该被强迫依赖它不使用的方法。

   → 小接口更容易复用。

5. 迪米特法则（最少知道原则）

   模块之间尽量少打交道，只与直接朋友通信。

   → 减少隐性依赖。

6. 🔨 三、实现高内聚低耦合的常用方法

技术/方法	说明
模块化设计	将系统按功能拆分成独立模块（UI、逻辑、数据层）
分层架构	典型如 MVC / MVP / MVVM，让各层职责单一
接口 + 抽象类	使用抽象接口作为模块边界，隐藏实现细节
依赖注入（DI）	把依赖关系交给外部容器或构造函数注入
事件/回调机制	模块之间通过事件或信号槽通信，而不是直接调用
设计模式应用	观察者、策略、工厂、适配器等都可降低耦合

🧠 四、示例（以 C++ 为例）

❌ 坏例（高耦合、低内聚)

class OrderProcessor {

public:

void process() {

// 订单逻辑

// 直接调用数据库操作

DBConnection db;

db.connect();

db.saveOrder(this);

// 直接打印日志

std::cout << "Order processed!" << std::endl;

}

};

好例（高内聚、低耦合）

class ILogger {

public:

virtual void log(const std::string& msg) = 0;

virtual ~ILogger() = default;

};

class IOrderRepository {

public:

virtual void save(const Order& order) = 0;

virtual ~IOrderRepository() = default;

};

class OrderProcessor {

IOrderRepository& repo;

ILogger& logger;

public:

OrderProcessor(IOrderRepository& r, ILogger& l) : repo(r), logger(l) {}

void process(const Order& order) {

repo.save(order);

logger.log("Order processed");

}

};

特点：

• 高内聚 ：OrderProcessor 只负责订单处理。

• 低耦合：通过接口依赖，数据库或日志实现可自由替换（例如文件日志、远程日志）。

• 符合依赖倒置：依赖抽象而非具体实现。

🧭 五、总结口诀

模块内：功能要聚焦（高内聚）

模块间：接口要解耦（低耦合）

或者更口语化一点：

"各司其职、相互独立、通过契约沟通、不要硬绑在一起。"

🎯 目标场景

我们要设计一个典型的 Qt 上位机程序，它包含以下模块：

• UI层：显示测试状态、用户操作按钮

• 业务逻辑层：控制测试流程（开始、停止、结果分析）

• 通信层：负责与硬件（比如测试机）通信

• 日志层：负责系统日志记录

• 🧩 一、结构设计（模块划分）

App

├── main.cpp

├── ui/

│ └── MainWindow.h / .cpp

├── core/

│ ├── TestController.h / .cpp ← 业务逻辑层（高内聚）

│ └── ICommInterface.h ← 通信接口抽象（低耦合）

├── comm/

│ ├── SerialComm.h / .cpp ← 串口实现

│ └── PcieComm.h / .cpp ← PCIe 实现

├── log/

│ └── Logger.h / .cpp

⚙️ 二、接口与实现（低耦合）

通信层接口抽象（ICommInterface.h）

#pragma once

#include <QObject>

#include <QByteArray>

class ICommInterface : public QObject {

Q_OBJECT

public:

explicit ICommInterface(QObject* parent = nullptr) : QObject(parent) {}

virtual ~ICommInterface() = default;

virtual bool connectDevice() = 0;

virtual void disconnectDevice() = 0;

virtual bool sendCommand(const QByteArray& data) = 0;

signals:

void dataReceived(const QByteArray& data);

};
串口通信实现（SerialComm.h/.cpp）

#pragma once

#include "ICommInterface.h"

#include <QSerialPort>

class SerialComm : public ICommInterface {

Q_OBJECT

QSerialPort port;

public:

bool connectDevice() override {

port.setPortName("COM3");

return port.open(QIODevice::ReadWrite);

}

void disconnectDevice() override {

port.close();

}

bool sendCommand(const QByteArray& data) override {

return port.write(data) == data.size();

}

private slots:

void onReadyRead() {

emit dataReceived(port.readAll());

}

};

✅ 通过接口实现隔离。

程序上层只依赖 ICommInterface，完全不关心底层是串口、USB 还是 PCIe

🔧 三、业务逻辑层（高内聚）

#pragma once

#include <QObject>

#include "ICommInterface.h"

#include "Logger.h"

class TestController : public QObject {

Q_OBJECT

ICommInterface* comm;

Logger* logger;

public:

TestController(ICommInterface* c, Logger* l, QObject* parent = nullptr)

: QObject(parent), comm(c), logger(l)

{

connect(comm, &ICommInterface::dataReceived, this, &TestController::onDataReceived);

}

public slots:

void startTest() {

logger->log("Test started");

comm->sendCommand("START");

}

void stopTest() {

logger->log("Test stopped");

comm->sendCommand("STOP");

}

private slots:

void onDataReceived(const QByteArray& data) {

logger->log("Data received: " + QString(data));

}

};

};

✅ TestController 只负责"测试业务逻辑"，

不关心通信是怎么实现的，也不直接操作UI。

四、UI层（信号槽解耦）

#pragma once

#include <QMainWindow>

#include <QPushButton>

#include "TestController.h"

class MainWindow : public QMainWindow {

Q_OBJECT

QPushButton *startBtn, *stopBtn;

TestController* controller;

public:

MainWindow(TestController* ctrl, QWidget* parent = nullptr)

: QMainWindow(parent), controller(ctrl)

{

startBtn = new QPushButton("Start", this);

stopBtn = new QPushButton("Stop", this);

startBtn->move(50, 50);

stopBtn->move(150, 50);

connect(startBtn, &QPushButton::clicked, controller, &TestController::startTest);

connect(stopBtn, &QPushButton::clicked, controller, &TestController::stopTest);

}

};

✅ UI 只负责交互，通过信号槽调用业务层接口，

无需了解通信细节或日志实现。

🧠 五、日志模块（可替换）

#pragma once

#include <QString>

#include <QDebug>

class Logger {

public:

void log(const QString& msg) {

qDebug() << "[LOG]" << msg;

}

};

未来你可以轻松替换成：

• 文件日志（写入文件）

• 网络日志（发送到远程服务器）

• GUI 日志面板（QTextEdit输出）

  不需要修改业务层的任何代码 → 低耦合的体现。

🧭 六、main.cpp（装配层，依赖注入）

#include <QApplication>
#include "MainWindow.h"
#include "SerialComm.h"
#include "Logger.h"

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    SerialComm comm;      // 可换成 PcieComm 等其他实现
    Logger logger;
    TestController controller(&comm, &logger);
    MainWindow w(&controller);
    w.show();

    return app.exec();
}
🧩 七、总结：Qt 中高内聚、低耦合的实现策略

层级	方法	效果
模块划分	UI、逻辑、通信、日志独立	职责单一（高内聚）
接口抽象	ICommInterface	解耦依赖（低耦合）
信号槽机制	UI ↔ Controller ↔ Comm	无直接依赖（低耦合）
依赖注入	main.cpp 组合对象	易于扩展、可测试
模块隔离	Logger、Comm 独立可替换	提高可维护性

🧱 十、简短总结口诀

高内聚 ：每个模块只管自己的事；
低耦合：模块之间靠接口对话。

在 C++ 服务系统中，这意味着：

• 用 抽象接口 + 依赖注入 + 分层架构 实现松耦合；

• 用 职责单一 + 内部封装 保证高内聚。