依赖倒置原则

依赖于抽象接口，不要依赖具体的实现（类），也就是针对接口编程。

#include<iostream>
using namespace std;

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

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

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

class Computer
{
public:
    Computer(HardDisk* harddisk,Memory* memory,Cpu* cpu)
    {
        M_hardDisk=harddisk;
        M_Memory=memory;
        M_Cpu=cpu;
    }
public:
    void work()
    {
        M_hardDisk->work();
        M_Memory->work();
        M_Cpu->work();
    }
protected:
private:
    HardDisk *M_hardDisk;
    Memory *M_Memory;
    Cpu *M_Cpu;
};

class InterCPU:public Cpu
{
public:
    void work()
    {
        cout<<"InterCPU 工作良好"<<endl;
    }
protected:
private:
};

class XSDisk:public HardDisk
{
public:
    void work()
    {
        cout<<"XSDisk工作良好"<<endl;
    }
protected:
private:
};

class JSDMemory:public Memory
{
public:
    void work()
    {
        cout<<"JSDMemory工作良好"<<endl;
    }
};

void main()
{
    HardDisk *harddisk = NULL;
    Memory *memory = NULL;
    Cpu *cpu = NULL;
    harddisk = new XSDisk;
    memory = new JSDMemory;
    cpu = new InterCPU;
    Computer *MyComputer = new Computer(harddisk,memory,cpu);
    MyComputer->work();
    delete harddisk;
    delete memory;
    delete cpu;
    delete MyComputer;
    system("pause");
}

电脑是高层业务逻辑，中间是抽象层（包括硬盘，CPU，内存），具体的产品分别是硬盘，CPU，内存是实现层。高层业务逻辑和具体产品（实现层）之间接耦合。其中类computer就是抽象接口。