c++依赖倒置原则

注：本文章是根据Easy搞定设计模式而写，转载请注明出处。

1、C++中什么是依赖倒置原则？
依赖倒置原则定义：依赖于抽象(接口)，不要依赖具体的实现(类)，也就是针对接口编程。

2、依赖倒置原则的图解。

3、你需要知道C++中的一个重要特性：高内聚，低耦合。高内聚，低耦合。高内聚，低耦合。

4、对于传统模式来说，我们实现的代码应该是这个样子的。

#include "iostream"
using namespace std;

class BankWorker{
public:/*纯虚函数的设计用来抽象银行业务员的业务*/
    virtual void doBusiness() = 0;
};

/*创建存钱的银行员*/
class saveBankWorker : public BankWorker{
public:
    virtual void doBusiness(){
        cout << "save money." << endl;
    }
};

/*创建转账的银行员*/
class transferBankWorker : public BankWorker{
public:
    virtual void doBusiness(){
        cout << "transfer money." << endl;
    }
};

/*创建取钱的银行员*/
class payBankWorker :public BankWorker{
public:
    virtual void doBusiness(){
        cout << "pay money." << endl;
    }
};

/*创建基金银行员*/
class fundationBankWorker :public BankWorker{
    virtual void doBusiness(){
        cout << "fundation money." << endl;
    }
};

//架构函数，高层业务层，依赖于接口BankWorker
void doBusiness(BankWorker *bw)
{
    //调用业务逻辑
    bw->doBusiness();
}

//实现层，同样的依赖于接口BankWorker
void printAllWorker()
{
        BankWorker *bw=NULL;

        bw = new saveBankWorker;  //将父类指针指向子类对象
        doBusiness(bw);           //高层调用业务函数
        delete bw;                //释放空间
        bw = NULL;                //将指针指向空，更加安全

        bw = new transferBankWorker;
        doBusiness(bw);
        delete bw;
        bw = NULL;

        bw = new payBankWorker;
        doBusiness(bw);
        delete bw;
        bw = NULL;

        bw = new fundationBankWorker;
        doBusiness(bw);
        delete bw;
        bw = NULL;
}

int main()
{
    printAllWorker();
    system("pause");
    return 0;
}

备注：传统的设计模式是自顶向下逐级依赖，这样一来，底层模块、中间模块和高层模块之间的耦合度就非常高，若任意修改其中一层，则很容易导致整个层次修改，非常的麻烦，因为他们之间的联系很强，所以，利用依赖倒置转换原则利用C++的多态特性，对中间抽象层进行依赖，这样底层和高层之间就脱离直接关系，就达到了解耦合的目的。

5、我们新设计一个符合依赖倒置转换原则的例子，是一个组装电脑的案例。
需求：假设现在组装一台电脑需要cpu，硬盘，内存，这三种器件可以相互对接（我的意思是硬件设备可以直接连接使用），然后电脑厂商可以根据不同的cpu，硬盘，内存进行搭配不同样式的电脑，在后期的升级和维护中，可能会有新的cpu、硬盘、内存品牌增加进行相互组合。

实现代码：

#include "iostream"
using namespace std;


/*
    抽象层(中间层)
*/
class HardDisk{
public:
    virtual void work()=0;
};

class Memory{
public:
    virtual void work()=0;
};

class Cpu{
public:
    virtual void work()=0;
};


/*
    让Computer 框架和具体的电脑产商 解耦合
*/
/*
    高层架构层，依赖于抽象层(中间层)
*/
class Computer{
public:
    Computer(Cpu *mycpu, Memory *mem, HardDisk *hard){
        m_cpu = mycpu;
        m_mem = mem;
        m_hard = hard;
    }

    //高层业务函数，只关心每个硬件的业务(是否工作等),并不关心硬件是那些个产商生产的
    void work(){
        m_cpu->work();
        m_mem->work();
        m_hard->work();
    }


private:
    Cpu *m_cpu=NULL;
    Memory *m_mem=NULL;
    HardDisk *m_hard=NULL;
};

/*
    实现层(底层),只需要依赖于中间抽象层，实现抽象层的方法
*/

class XiJieHardDisk :public HardDisk{
public:
    virtual void work(){
        cout << "XiJie HardDisk working..." << endl;
    }
};

class InterCpu :public Cpu{
public:
    virtual void work()
    {
        cout << "Inter Cpu working..." << endl;
    }
};

class JSDMemory :public Memory{
public:
    virtual void work()
    {
        cout << "JSD Memory working" << endl;
    }
};

int main()
{
    XiJieHardDisk *xjdisk = new XiJieHardDisk;
    InterCpu *intercpu = new InterCpu;
    JSDMemory *jsdmemory = new JSDMemory;

    Computer *myComputer = new Computer(intercpu, jsdmemory, xjdisk);
    myComputer->work();

    delete xjdisk;
    delete intercpu;
    delete jsdmemory;
    delete myComputer;

    system("pause");
    return 0;
}

备注：利用此种方法可以完美的解决后期新的品牌加入问题，同时将底层和高层进行分离，可以更好的管理自己的代码。

同时也可以参考开闭原则，仔细比较二者之间不同。开闭原则链接