C++ 设计模式六大原则：单一、依赖倒置与迪米特法则实战解析

单一职责与依赖倒置原则

单一职责原则（SRP）要求一个类或模块只负责一项业务逻辑，避免类内部变化的原因超过一个。在早期的银行职员设计中，如果将“存款”、“取款”和“缴费”全部集中在同一个类中，一旦某项流程变更，整个类都需要重新审视。通过提取抽象基类并实现具体功能类，可以实现职责分离。

依赖倒置原则（DIP）强调高层模块不应依赖低层模块，两者都应依赖其抽象。针对接口编程而非实现编程，能有效解耦。以下是基于 C++ 的多态实现示例：

基础案例：银行账户操作重构

首先定义一个包含所有操作的粗粒度类，随后将其拆分为抽象接口与具体实现类，以实现高内聚低耦合。

#include<iostream> 
using namespace std; 

// 传统方式：职责混杂 
class BankWorker { 
public: 
    void save() {
        cout << "存款" << endl;
    } 
    void moveM() {
        cout << "取款" << endl;
    } 
    void jiaofei() {
        cout << "缴费" << endl;
    } 
}; 

// 依赖倒置方式：定义抽象接口 
class AbBankWorker { 
public: 
    virtual void dothing() = 0; 
}; 

// 具体实现：存款 
class SaveBanker : public AbBankWorker { 
public: 
    virtual void dothing() {
        cout << "存款" << endl;
    } 
}; 

// 具体实现：取款 
class MoveBanker : public AbBankWorker { 
public: 
    virtual void dothing() {
        cout << "取款" << endl;
    } 
}; 

// 具体实现：缴费 
class PayBanker : public AbBankWorker { 
public: 
    virtual void dothing() {
        cout << "缴费款" << endl;
    } 
}; 

void main22() {
    AbBankWorker*bw = NULL;
    bw = new MoveBanker;
    bw->dothing();
    delete bw;
    return;
}

接口隔离与里氏替换原则

接口隔离原则要求客户端不应该被迫依赖于它不使用的方法。若一个庞大的接口包含多种功能，强行让某些类实现不相关方法会造成浪费与设计污染。里氏替换原则则是面向对象的基础，子类应当能够替换父类出现在任何地方，而不会导致程序错误。

下面通过计算机硬件组件的组合，演示如何通过多态实现硬件无关性的设计，这既是依赖倒置的实践，也符合里氏替换的规范。

#include<iostream> 
using namespace std;

// 抽象接口 
class HardDisk {public:
    virtual void work(); 
}; 
class Memory { 
public: 
    virtual void work(); 
}; 
class Cpu { 
public: 
    virtual void work(); 
}; 

// 使用抽象接口组合，而非具体实现 
class ComPuter { 
public:
    // 构造函数注入抽象依赖 
    ComPuter(HardDisk*m_handdisk, Memory*m_memory, Cpu*m_cpu) {
        m_handdisk = m_handdisk;
        m_memory = m_memory;
        m_cpu = m_cpu;
    }
public:
    void work() {
        m_handdisk->work();
        m_memory->work();
        m_cpu->work();
    }
private:
    HardDisk*m_handdisk; 
    Memory*m_memory; 
    Cpu*m_cpu;
}; 

// 具体实现遵循抽象接口 
class InterCpu : public Cpu { 
public: 
    void work() { 
        cout << "我是因特尔厂家" << endl;
    }
}; 
class XSDisk : public HardDisk { 
public: 
    void work() { 
        cout << "我是西数硬盘厂家" << endl;
    }
}; 
class JSDMem : public Memory { 
public: 
    void work() { 
        cout << "我是JSDMem厂家" << endl;
    }
}; 

优先使用组合而非继承

在 ComPuter 类的实现中，我们使用了对象组合而非多重继承来组装 CPU、内存和硬盘。继承会导致强耦合，父类的任何变动都可能影响子类行为。相比之下，组合降低了类之间的依赖关系，使得系统更加灵活且易于测试。

迪米特法则（最少知识原则）

迪米特法则指出，一个对象应当对其他对象尽可能少地了解。在高耦合系统中，修改一个模块可能会引发其他模块的连锁反应。通过提供统一的接口来实现交互，各模块无需知晓对方内部细节，这就是所谓的黑盒原理。良好的封装是实现这一原则的关键，例如在本例中，ComPuter 只需要知道 HardDisk 有 work() 方法即可，无需关心硬盘的内部构造。

以上就是 C++ 设计模式六大基本原则的详细内容，更多关于 C++ 设计模式进阶的资料请关注本站其它相关文章！