zoukankan      html  css  js  c++  java
  • 设计模式C++描述----06.适配器(Adapter)模式

    一. 定义

    适配器模式将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

    Adapter 模式的两种类别:类模式对象模式

    二. 举例说明

    实际中,我们为了完成某项工作购买了一个第三方的库来加快开发。这个库可能都是一些.dll文件,这就带来了一个问题!我们在应用程序中已经设计好 了接口,与这个第三方提供的接口不一致,为了使得这些接口不兼容的类(不能在一起工作)可以在一起工作了,Adapter模式提供了将一个类(第三方库) 的接口转化为客户(购买使用者)希望的接口的方法。

    三. 代码实现

    类模式的Adapter采用继承的方式复用Adaptee的接口。


    1. //目标类,可以想像成客户所期代的接口  
    2. class Target  
    3. {  
    4. public:  
    5.     Target()  
    6.     {  
    7.     }  
    8.   
    9.     virtual ~Target()  
    10.     {  
    11.     }  
    12.   
    13.     virtual void Request()  
    14.     {  
    15.         std::cout<<"Target::Request"<<std::endl;  
    16.     }  
    17. };  
    18.   
    19. //被适应者,可以看成 dll 提供的接口  
    20. class Adaptee  
    21. {  
    22. public:  
    23.     Adaptee()  
    24.     {  
    25.     }  
    26.   
    27.     virtual ~Adaptee()  
    28.     {  
    29.     }  
    30.   
    31.     void SpecificRequest()  
    32.     {  
    33.         std::cout<<"Adaptee::SpecificRequest"<<std::endl;  
    34.     }  
    35. };  
    36.   
    37. //适配器类,通过在内部包装被适应者对象 adaptee  
    38. //把源接口(SpecificRequest)转换成目标接口(Request)  
    39. class Adapter: public Target, private Adaptee  
    40. {  
    41. public:  
    42.     void Request()  
    43.     {  
    44.         this->SpecificRequest();  
    45.     }  
    46. };  
    47.   
    48.   
    49. //测试代码  
    50. int main(int argc,char* argv[])  
    51. {  
    52.     Adaptee* ade = new Adaptee;  
    53.     Target* adt = new Adapter;  
    54.   
    55.     adt->Request();  
    56.   
    57.     return 0;  
    58. }  

    对象模式的Adapter中则采用组合的方式实现Adaptee的复用。


    1. //目标类  
    2. class Target  
    3. {  
    4. public:  
    5.     virtual ~Target() {}  
    6.       
    7.     virtual void Request()  
    8.     {  
    9.         std::cout<<"Target::Request"<<std::endl;  
    10.     }  
    11. };  
    12.   
    13. //被适应类  
    14. class Adaptee  
    15. {  
    16. public:  
    17.     virtual ~Adaptee() {}  
    18.   
    19.     void SpecificRequest()  
    20.     {  
    21.         std::cout<<"Adaptee::SpecificRequest"<<std::endl;  
    22.     }  
    23. };  
    24.   
    25. //适配器类,用于转接两者的接口  
    26. class Adapter:public Target  
    27. {  
    28. public:  
    29.     Adapter(Adaptee* ade)  
    30.     {  
    31.         this->_ade= ade;  
    32.     }  
    33.   
    34.     void Request()  
    35.     {  
    36.         _ade->SpecificRequest();  
    37.     }  
    38.   
    39. private:  
    40.     Adaptee* _ade;  
    41. };  
    42.   
    43.   
    44. //测试代码  
    45. int main(int argc,char* argv[])  
    46. {  
    47.     Adaptee* ade = new Adaptee;  
    48.     Target* adt = new Adapter(ade);  
    49.       
    50.     adt->Request();  
    51.   
    52.     return 0;  
    53. }  

    四. 说明

    1. 当接口不同时,首先不应该考虑用适配器,而是应该考虑通过重构统一接口。

    2. 使用适配器模式是无奈之举,通常在软件开发后期或维护期再考虑使用。

  • 相关阅读:
    一小时学会前端工程化
    lodash学习资料
    关于《冬天时我喜欢靠近温暖的事》这首歌 (民谣在路上)
    往后余生(简单的歌词分享)
    如果觉得活的很累不妨进来看看(生活应该简简单单)
    《大学》全文及白话翻译
    原型设计模式 Prototype
    解释器模式 Interpreter
    copy on write,代理模式
    ado.net
  • 原文地址:https://www.cnblogs.com/any91/p/3247980.html
Copyright © 2011-2022 走看看