C++ 设计模式的基本原则

设计模式基本原则

最终目的，高内聚，低耦合

开放封闭原则类的改动是通过增加代码进行的，不是修改源代码

银行类案例代码

1. #include<iostream> 
2. using namespace std; 
3. class BankWorker 
4. { 
5. public: 
6.     void save() 
7.     { 
8.         cout << "存款" << endl; 
9.     } 
10.     void moveM() 
11.     { 
12.         cout << "取款" << endl; 
13.  
14.     } 
15.     void jiaofei() 
16.     { 
17.         cout << "缴费" << endl; 
18.     } 
19.  
20. }; 
21. class AbBankWorker 
22. { 
23. public: 
24.     virtual void dothing() = 0; 
25. }; 
26.  
27. class SaveBanker :public AbBankWorker 
28. { 
29. public: 
30.     virtual  void dothing() 
31.     { 
32.         cout << "存款" << endl; 
33.     } 
34. }; 
35. class MoveBanker :public AbBankWorker 
36. { 
37. public: 
38.     virtual  void dothing() 
39.     { 
40.         cout << "取款" << endl; 
41.     } 
42. }; 
43. class SaveBanker :public AbBankWorker 
44. { 
45. public: 
46.     virtual  void dothing() 
47.     { 
48.         cout << "缴费款" << endl; 
49.     } 
50. }; 
51. void main11() 
52. { 
53.     BankWorker*bw = new BankWorker; 
54.     bw->jiaofei(); 
55.     bw->moveM(); 
56.     bw->save(); 
57.     cout << "hello..." << endl; 
58.     system("pause"); 
59.     return; 
60.      
61. } 
62. void main22() 
63. { 
64.     AbBankWorker*bw = NULL; 
65.         bw=new MoveBanker; 
66.         bw->dothing(); 
67.         delete bw; 
68.     return; 
69.  
70. } 
71. void main() 
72. { 
73.  
74.     main22(); 
75.      
76.     system("pause"); 
77.     return; 
78. } 

单一职责原则类的职责要单一，对外只提供一种功能，而引起内变化的原因都应该只有一个

依赖倒置原则依赖于抽象接口，不要依赖具体的实现类，也就是针对接口编程

1. #include<iostream> 
2. using namespace std; 
3. class HardDisk 
4. {public: 
5.     virtual void work(); 
6. }; 
7.  
8. class Memory 
9. { 
10. public: 
11.     virtual void work(); 
12. }; 
13. class Cpu 
14. { 
15. public: 
16.     virtual void work(); 
17. }; 
18. class ComPuter 
19. { 
20. public: 
21.     ComPuter(HardDisk*m_handdisk, Memory*m_memory, Cpu*m_cpu) 
22.     { 
23.         m_handdisk = handdisk; 
24.         m_memory = memory; 
25.         m_cpu = cpu; 
26.     } 
27. public: 
28.     void work() 
29.     { 
30.         m_handdisk->work(); 
31.         m_memory->work(); 
32.         m_cpu->work(); 
33.     } 
34. private: 
35.     HardDisk*m_handdisk; 
36.         Memory*m_memory; 
37.         Cpu*m_cpu; 
38. }; 
39.  
40. class InterCpu :public Cpu 
41. { 
42. public: 
43.     void work() 
44.     { 
45.         cout << "我是因特尔厂家" << endl; 
46.     } 
47. }; 
48. class XSDisk :public HardDisk 
49. { 
50. public: 
51.     void work() 
52.     { 
53.         cout << "我是西数硬盘厂家" << endl; 
54.     } 
55. }; 
56. class JSDMem :public Memory 
57. { 
58. public: 
59.     void work() 
60.     { 
61.         cout << "我是JSDMem厂家" << endl; 
62.     } 
63. }; 
64. void main() 
65. { 
66.     HardDisk*handdisk=NULL; 
67.     Memory*memory=NULL; 
68.     Cpu*cpu=NULL; 
69.     handdisk = new XSDisk; 
70.     memory= new JSDMem; 
71.     cpu = new InterCpu; 
72.     ComPuter*mycomputer = new ComPuter(harddisk, memory, cpu); 
73.     mycomputer->work(); 
74.     delete mycomputer; 
75.     delete cpu; 
76.     delete  memory; 
77.     delete  harddisk; 
78.     cout << "hello" << endl; 
79.     system("pause"); 
80.     return; 
81. } 

接口隔离原则不应该强迫客户的程序依赖他们不需要的接口方法，一个接口应该是提供一种对外功能，不应该把所有的操作都封装到一个接口中去

里氏替换原则任何抽象类出现的地方都可以用它的实现类进行替换，实际就是虚拟机智语言级别，实现面向对象功能

优先使用组合而不是继承原则如果使用继承，会导致复位的任何变化，都可能影响此类的行为，如果使用对象组合，就降低了这种依赖关系

迪米特法则一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如，在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现，这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变的时候，不会影响其他模块的使用黑盒原理。

原文地址：https://www.toutiao.com/a7006942190798668292/