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

时间:2021-10-27 06:48:09

设计模式基本原则

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

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

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

银行类案例代码

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

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

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

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

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

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

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

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

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