作者:HuangYuXuan
内容:内聚 和 耦合 的样式和示例
时间:2023/12/5
耦合的样式和示例
"耦合"是软件工程中描述两个模块之间关系的术语,它表示模块间的相互依赖程度。不同的耦合程度可以影响系统的可维护性、可扩展性和可重用性。以下是一些常见的耦合模式及其示例:
-
非直接耦合(No Coupling)
-
描述: 模块之间没有直接的依赖关系,彼此独立。
-
示例: 两个完全独立的库,彼此无关。
-
代码示例:
#include <iostream> #include <string> //中介者模式 实现非直接耦合 class Colleague; class Mediator { public: virtual void sendMessage(const std::string& message, Colleague* colleague) const = 0; }; class ConcreteMediator : public Mediator { public: void setColleague1(Colleague* colleague) { colleague1 = colleague; } void setColleague2(Colleague* colleague) { colleague2 = colleague; } void sendMessage(const std::string& message, Colleague* colleague) const override { if (colleague == colleague1) { colleague2->receiveMessage(message); } else if (colleague == colleague2) { colleague1->receiveMessage(message); } } private: Colleague* colleague1; Colleague* colleague2; }; class Colleague { public: Colleague(Mediator* mediator, const std::string& name) : mediator(mediator), name(name) { } virtual void sendMessage(const std::string& message) const { mediator->sendMessage(message, this); } virtual void receiveMessage(const std::string& message) const = 0; protected: Mediator* mediator; std::string name; }; class ConcreteColleague : public Colleague { public: ConcreteColleague(Mediator* mediator, const std::string& name) : Colleague(mediator, name) { } void receiveMessage(const std::string& message) const override { std::cout << "Colleague " << name << " received message: " << message << std::endl; } }; int main() { ConcreteMediator mediator; ConcreteColleague colleague1(&mediator, "Colleague1"); ConcreteColleague colleague2(&mediator, "Colleague2"); mediator.setColleague1(&colleague1); mediator.setColleague2(&colleague2); colleague1.sendMessage("Hello, colleagues!"); return 0; }
-
-
数据耦合(Data Coupling)
-
描述: 模块之间通过参数传递简单的数据结构进行通信。
-
示例: 一个函数接受参数,并使用这些参数进行计算,没有直接调用其他函数或模块。
-
代码示例:
#include <iostream> #include <string> // 模块A class ModuleA { public: void performOperation(ModuleB& moduleB, const std::string& data) { std::cout << "ModuleA is performing an operation with data: " << data << std::endl; moduleB.receiveData(data); } }; // 模块B class ModuleB { public: void receiveData(const std::string& data) { std::cout << "ModuleB received data: " << data << std::endl; } }; int main() { ModuleA moduleA; ModuleB moduleB; // 模块A执行操作,并通过参数传递数据给模块B moduleA.performOperation(moduleB, "Hello, ModuleB!"); return 0; }
-
-
标记耦合(Stamp Coupling)
-
描述: 模块之间通过传递复杂的数据结构,其中只有一部分被使用。
-
示例: 一个函数接受一个结构体,但只使用其中的一部分数据。
-
代码示例:
#include <iostream> #include <string> struct DataStructure { int tag; std::string data; DataStructure(int t, const std::string& d) : tag(t), data(d) {} }; // 模块A class ModuleA { public: void performOperation(ModuleB& moduleB, const DataStructure& dataStructure) { std::cout << "ModuleA is performing an operation with data: " << dataStructure.data << std::endl; moduleB.receiveData(dataStructure); } }; // 模块B class ModuleB { public: void receiveData(const DataStructure& dataStructure) { std::cout << "ModuleB received data with tag: " << dataStructure.tag << std::endl; } }; int main() { // 创建模块A和模块B的实例 ModuleA moduleA; ModuleB moduleB; DataStructure dataStructure(42, "Hello, ModuleB!"); moduleA.performOperation(moduleB, dataStructure); return 0; }
-
-
控制耦合(Control Coupling)
-
描述: 模块之间通过传递控制信息(如标志位)进行通信。
-
示例: 一个函数接受一个布尔值,根据该值的真假执行不同的操作。
-
代码示例:
#include <iostream> // 模块A class ModuleA { public: void performOperation(ModuleB& moduleB, bool controlFlag) { std::cout << "ModuleA is performing an operation with control flag: " << controlFlag << std::endl; moduleB.receiveControlFlag(controlFlag); } }; // 模块B class ModuleB { public: void receiveControlFlag(bool controlFlag) { if (controlFlag) { std::cout << "ModuleB received control flag: true - Performing specific action." << std::endl; } else { std::cout << "ModuleB received control flag: false - Performing default action." << std::endl; } } }; int main() { // 创建模块A和模块B的实例 ModuleA moduleA; ModuleB moduleB; moduleA.performOperation(moduleB, true); moduleA.performOperation(moduleB, false); return 0; }
-
-
外部耦合(External Coupling)
-
描述: 两个模块之间通过共享的全局数据进行通信。
-
示例: 多个模块共享一个全局变量,通过该变量进行数据传递。
-
代码示例:
#include <iostream> #include <string> // 共享的全局数据 class SharedData { public: static std::string sharedMessage; static void setSharedMessage(const std::string& message) { sharedMessage = message; } static std::string getSharedMessage() { return sharedMessage; } }; // 模块A class ModuleA { public: void performOperation() { std::cout << "ModuleA is performing an operation with shared data: " << SharedData::getSharedMessage() << std::endl; } }; // 模块B class ModuleB { public: void performOperation() { std::cout << "ModuleB is performing an operation with shared data: " << SharedData::getSharedMessage() << std::endl; } }; std::string SharedData::sharedMessage = ""; int main() { // 创建模块A和模块B的实例 ModuleA moduleA; ModuleB moduleB; SharedData::setSharedMessage("Hello, Modules!"); moduleA.performOperation(); moduleB.performOperation(); return 0; }
-
-
内容耦合(Content Coupling)
-
描述: 一个模块直接访问另一个模块的内部实现。
-
示例: 一个模块直接访问另一个模块的私有成员变量或函数。
-
代码示例:
#include <iostream> #include <string> // 模块A class ModuleA { public: void performOperation() { ModuleB moduleB; std::cout << "ModuleA is performing an operation using ModuleB's internal implementation." << std::endl; moduleB.internalImplementation(); } }; // 模块B class ModuleB { public: void internalImplementation() { std::cout << "ModuleB's internal implementation." << std::endl; } }; int main() { // 创建模块A的实例 ModuleA moduleA; moduleA.performOperation(); return 0; }
-
在设计软件时,通常会尽量减少耦合,特别是高度耦合,以提高系统的灵活性、可维护性和可扩展性。使用合适的设计模式和良好的软件架构可以帮助降低耦合度。
内聚的样式和示例
"内聚"是软件工程中描述模块内部组织和结构的术语,它表示模块内部各个元素之间相互关联的紧密程度。高内聚性意味着模块内部的元素紧密相关,执行相似的任务,而低内聚性则表示模块内部的元素关联性较弱。以下是一些常见的内聚类型及其示例:
-
功能内聚(Functional Cohesion)
-
描述: 模块内的元素执行相似的功能,完成一个具体的任务。
-
示例: 一个计算平均值的模块,其中包含计算总和、计数和平均值的功能。
-
代码示例:
#include <iostream> #include <vector> class DataProcessor { public: DataProcessor() {} // 计算总和的功能 int calculateSum(const std::vector<int>& data) const { int sum = 0; for (int value : data) { sum += value; } return sum; } // 计算平均值的功能 double calculateAverage(const std::vector<int>& data) const { if (data.empty()) { return 0.0; } int sum = calculateSum(data); return static_cast<double>(sum) / data.size(); } void processData(const std::vector<int>& data) const { int sum = calculateSum(data); double average = calculateAverage(data); std::cout << "Sum: " << sum << std::endl; std::cout << "Average: " << average << std::endl; } }; int main() { DataProcessor dataProcessor; std::vector<int> data = {1, 2, 3, 4, 5}; dataProcessor.processData(data); return 0; }
-
-
顺序内聚(Procedural Cohesion)
-
描述: 模块内的元素按照一定的顺序执行,但不一定要求输出作为下一个元素的输入。
-
示例: 一个数据处理模块,其中包含数据采集、数据清理、数据分析等步骤。
-
代码示例:
#include <iostream> #include <vector> class DataProcessor { public: void processData(const std::vector<int>& data) const { int sum = calculateSum(data); displayResults(sum); } private: // 计算总和的功能 int calculateSum(const std::vector<int>& data) const { int sum = 0; for (int value : data) { sum += value; } return sum; } // 显示结果的功能 void displayResults(int sum,) const { std::cout << "Sum: " << sum << std::endl; } }; int main() { std::vector<int> data = {1, 2, 3, 4, 5}; DataProcessor dataProcessor; dataProcessor.processData(data); return 0; }
-
-
通信内聚(Communicational Cohesion)
-
描述: 模块内的元素共享相同的数据,彼此之间通过数据进行通信。
-
示例: 一个模块,包含对共享数据结构进行读写的函数。
-
代码示例:
#include <iostream> #include <vector> struct SharedData { std::vector<int> data; int flag; SharedData(const std::vector<int>& d, int f) : data(d), flag(f) {} }; class DataProcessor { public: DataProcessor(const SharedData& sharedData) : sharedData(sharedData) {} void processData() const { int sum = calculateSum(); double average = calculateAverage(); std::cout << "Sum: " << sum << std::endl; std::cout << "Average: " << average << std::endl; } private: // 计算总和的功能 int calculateSum() const { int sum = 0; for (int value : sharedData.data) { sum += value; } return sum; } // 计算平均值的功能 double calculateAverage() const { if (sharedData.data.empty()) { return 0.0; } int sum = calculateSum(); return static_cast<double>(sum) / sharedData.data.size(); } const SharedData& sharedData; }; int main() { std::vector<int> data = {1, 2, 3, 4, 5}; int flag = 42; SharedData sharedData(data, flag); DataProcessor dataProcessor(sharedData); dataProcessor.processData(); return 0; }
-
-
过程内聚(Procedural Cohesion)
-
描述: 如果一个模块内的处理元素是相关的,而且必须以特定的次序执行。
-
示例: 一个图形处理模块,其中包含不同的函数用于绘制图形、填充颜色等,它们可以以任意顺序调用。
-
代码示例:
#include <iostream> #include <string> void validateOrder(int orderId) { std::cout << "Validating order: " << orderId << std::endl; } double calculateTotalPrice(int quantity, double pricePerUnit) { return quantity * pricePerUnit; } void updateInventory(int productId, int quantity) { std::cout << "Updating inventory for product " << productId << " with quantity " << quantity << std::endl; } void processOrder(int orderId, int productId, int quantity, double pricePerUnit) { validateOrder(orderId); double totalPrice = calculateTotalPrice(quantity, pricePerUnit); std::cout << "Total Price: " << totalPrice << std::endl; updateInventory(productId, quantity); std::cout << "Order processed successfully!" << std::endl; } int main() { processOrder(1, 1001, 5, 25.99); return 0; }
-
-
时间内聚(Temporal Cohesion)
-
描述: 模块内的元素在同一时间段内执行,完成一个相关的任务。
-
示例: 一个初始化模块,包含系统启动时需要执行的一系列初始化操作。
-
代码示例:
#include <iostream> #include <vector> #include <string> //数据A class Data_A{ public: Data_A(int number,std::string str,std::vector<int> Array) :_number(number), _str(str), _Array(Array) {} Data_A(const Data_A&&) = default; Data_A& operator=(const Data_A&&) = default; private: int _number; std::string _str; std::vector<int> _Array; }; //数据B class Data_B{ public: Data_B(int number,std::string str) :_number(number), _str(str), {} Data_B(const Data_B&&) = default; Data_B& operator=(const Data_B&&) = default; private: int _number; std::string _str; }; static Data_A memory_A static Data_A memory_B void Data_init(Data_A temp_memory_A,Data_B temp_memory_b){ memory_A = std::move(temp_memory_A); memory_B = std::move(temp_memory_B); //... to Do } int main(){ Data_init({10,"Hello",{1,2}},{12,"world"}); }
-
-
逻辑内聚(Logical Cohesion)
-
描述: 模块内的元素执行相似的逻辑操作,但没有具体的功能关联。
-
示例: 一个包含一组杂乱功能的工具类,它们通过共享某种上下文或领域而放在同一个模块中。
-
代码示例:
#include <iostream> void validateOrder(int orderId) { std::cout << "Validating order: " << orderId << std::endl; } double calculateTotalPrice(int quantity, double pricePerUnit) { return quantity * pricePerUnit; } void updateInventory(int productId, int quantity) { std::cout << "Updating inventory for product " << productId << " with quantity " << quantity << std::endl; } void printOrderInfo(int orderId, int productId, int quantity, double pricePerUnit) { std::cout << "Order Info - Order ID: " << orderId << ", Product ID: " << productId << ", Quantity: " << quantity << ", Price per Unit: " << pricePerUnit << std::endl; } void processOrder(int orderId, int productId, int quantity, double pricePerUnit) { validateOrder(orderId); double totalPrice = calculateTotalPrice(quantity, pricePerUnit); std::cout << "Total Price: " << totalPrice << std::endl; updateInventory(productId, quantity); printOrderInfo(orderId, productId, quantity, pricePerUnit); std::cout << "Order processed successfully!" << std::endl; } int main() { processOrder(1, 1001, 5, 25.99); return 0; }
-
-
偶然内聚(Coincidental Cohesion)
-
描述: 模块内的元素没有明显的相关性,它们被放在同一个模块中是偶然的。
-
示例: 一个包含了无关联的各种杂乱功能的工具类,没有明显的组织结构。
-
代码示例:
#include <iostream> void processData(int data) { std::cout << "Processing data: " << data << std::endl; } void generateReport() { std::cout << "Generating report." << std::endl; } void sendNotification(const std::string& message) { std::cout << "Sending notification: " << message << std::endl; } int main() { int data = 42; processData(data); generateReport(); std::string notificationMessage = "Important message!"; sendNotification(notificationMessage); return 0; }
-
高内聚性有助于提高代码的可维护性、可读性和重用性,因此在软件设计中通常被认为是一个重要的设计原则。