设计模式----依赖倒置原则

一般情况下进行对象编程，以来都是自上而下的依赖，比如说:

举一个例子:

class Bank {
public:
	virtual void DoThings() = 0;
protected:

private:

};

class SaveEmp : public Bank {
public:
	void DoThings() {
		cout << "存款" << endl;
	}
};

class CarryOverEmp : public Bank {
public:
	void DoThings() {
		cout << "转账" << endl;
	}
};

class PayEmp : public Bank {
public:
	void DoThings() {
		cout << "交费" << endl;
	}
};

void BankWork(Bank *bk) {
	bk->DoThings();
}

int main() {
	Bank* bkSave = new SaveEmp;
	Bank* bkCarry = new CarryOverEmp;
	Bank* bkPay = new PayEmp;

	BankWork(bkPay);
	BankWork(bkSave);

	BankWork(bkCarry);

	system("pause");

	return(0);
}

而依赖倒置原则要求依赖方向向中间的抽象层聚集:

看一个具体的例子:

类图的代码实现:

#include <iostream>

using namespace std;

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

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

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



class Computer {
public:
	Computer(Cpu *cpu, Memo *mem, HardDisk *hard) : m_cpu(cpu), m_memo(mem), m_hard(hard){

	}
public:
	void work() {
		m_cpu->work();
		m_memo->work();
		m_hard->work();
	}
private:
	Cpu* m_cpu;
	Memo* m_memo;
	HardDisk* m_hard;
};

class IntelCpu : public Cpu {
public:
	void work() {
		cout << "我是Intel CPU!" << endl;
	}
};

class XiShuHardDisk : public HardDisk {
public:
	void work() {
		cout << "我是西数硬盘!" << endl;
	}
};

class JSDMem : public Memo {
public:
	void work() {
		cout << "我是金士顿内存!" << endl;
	}
};



int main() {
	HardDisk* _hd = NULL;
	Memo* _mem = NULL;
	Cpu* _cpu = NULL;

	_mem = new JSDMem;
	_hd = new XiShuHardDisk;
	_cpu = new IntelCpu;

	Computer* p = new Computer(_cpu, _mem, _hd);
	p->work();
        delete _hd;
        delete _mem;
        delete _cpu;
        delete _p;
	system("pause");

	return(0);
}

(完)