设计模式

1、适配器Adapter(wrapper)模式  

定义：

       讲一个类的接口转换成客户希望使用的另外一个接口，解决两个接口之间不匹配的问题。Adatper模式

使得原本接口不兼容而不能一起工作的那些类可以一起工作。

角色：

• Target对象：负责定义所需要的方法，具体的业务需求（客户要求的）。
• Client请求者：负责使用Target角色定义的方法做具体处理。
• Adaptee适配器:一个持有既定方法的角色。
• Adapter适配器：Adapter模式的主人公，使用Adaptee的方法来满足Target的需求。

实现：

      有两种方法：

      ①、类版本：可以方便地修改适配对象的部分行为（重载），但适配多个不同类型的功能时（多个接口或者需要多个类），实现比较复杂，而且

继承会带来意向不到的问题（比如Adaptee又有人添加了新的方法）。

      ②、对象版本：可以一次适配所有的子类，也建议用这一种方法。

对象实现代码：

#include<iostream>
using namespace std;
class Target
{
public:
    Target(){}
    virtual ~Target(){}
    virtual void Request()
    {
        cout<<"Target::Request"<<endl;
    }
};
 
class Adaptee
{
public:
    void SpecificRequest()
    {
        cout<<"Adaptee::SpecificRequest"<<endl;
    }
};
 
class Adapter : public Target
{
public:
    Adapter() : m_Adaptee(new Adaptee) {}
 
    ~Adapter()
    {
        if (m_Adaptee != NULL)
        {
            delete m_Adaptee;
            m_Adaptee = NULL;
        }
    }
 
    void Request()
    {
        m_Adaptee->SpecificRequest();
    }
 
private:
    Adaptee *m_Adaptee;
};
 
int main(int argc, char *argv[])
{
    Target *targetObj = new Adapter();
    targetObj->Request();
 
    delete targetObj;
    targetObj = NULL;
 
    return 0;
}

2、工厂模型设计    

3、组合模式（Composite)的设计     ，

定义：

Compose objects into tree strucgures to represent part-whole hierarchies.
Composite lets clients treat individual objects and compositions of objects uniformly.

要点：

1、组合模式让我们能用树形方式创建对象的结构，树里面包含了组合以及个别对象。

2、组合模式允许客户对个别对象（叶节点）以及组合对象一视同仁。

3、组合结构内的任意对象称为组件，组件可以是组合，也可以是叶节点。

4、页节点和组合必须实现相同的接口。

类图：

Component：组合中所有对象接口，不管是组合还是叶节点。

Leaf:叶节点。

Composite:组合，包含一个或多个孩子（可以是叶节点，也可以是组合）。

示例：

4、单例模式的设计。

　　　C++中的单例模式，保证一个类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的模块，

如系统的日志输出等。

　　   按照C语言的风格，甚至可以直接使用一个全局变量做到这一点，但这样的代码显的很不优雅。《设计模式》一书中给出了一种不错的实现。

 1 class CSingleton
 2 {
 3  public:
 4      static CSingleton *GetInstane()
 5      {
 6           if(NULL == m_pInstance)
 8                 m_pInstance = new CSingleton();
 9           return m_pInstance;      
11      }
12  private:
13      CSingleton()
14      {
15      }       
16      static CSingleton *m_pInstance;    
17 }
　　CSingleton* CSingleton::m_pInstance = NULL;//初始化静态变量

单例类CSingleton有以下特征：
1、它有一个指向唯一实例的静态指针m_pInstance，并且是私有的。
2、它有一个共有的函数，可以获取这个唯一的实例，并在需要的时候创建该
实例。
3、它的构造函数是私有的，这样就不能从别处创建该类的实例。

　　有经验的读者可能会问，m_pInstance指向的空间什么时候释放？更严重的问题是，这个实例的析构函数什么时候执行？如果在类中的析构行为中有必须的操作，比如关闭文件、释放外部资源

，上面的代码无法实现这个要求。我们需要一种方法，正常的删除该实例。

　　可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能，但是不仅丑陋，而且容易出错，因为这样的附加代码很容易忘记，而且也很难保证在delete之后，没有代码

再调用GetInstance函数，一个妥善的方法是让这个类自己知道在合适的时候把自己删除。我们知道，程序在结束的时候，系统会自动析构所有的全局变量，事实上，系统也会析构所有类的静态成员变量。

利用这一个特征，我们可以在c++单例模式中定义这样一个静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中CGarbo类(Garbo意为垃圾工人） 1 class CSingleton:   2 {  

 3 // 其它成员  
 4 public:  
 5     static CSingleton * GetInstance()
 6     {
 7         if( NULL == m_pInstance)
 8             m_pInstance = new CSingleton();
 9         return m_pInstance;
10     }  
11 private:  
12     CSingleton()
13     {
14     } 
15     static CSingleton * m_pInstance;  
16     class CGarbo // 它的唯一工作就是在析构函数中删除CSingleton的实例  
17     {  
18         public:  
19         ~CGarbo()  
20         {  
21             if (CSingleton::m_pInstance)  
22                 delete CSingleton::m_pInstance;  
23         }  
24     };   
25     static CGarbo Garbo; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数  
26 }   
　　CSingleton* CSingleton::m_pInstance = NULL;//初始化静态变量
　　CSingleton::CGarbo CSingleton::CGarbo;//初始化静态变量

主要以下特征：
1、在单例内部定义专有的嵌套类，以防止该类在其他地方滥用。
2、在单例类内定义私有的专门用于释放的静态成员。
3、利用程序在结束时析构全局变量的特性，选择最终的释放时机。
4、使用c++单例模式的代码不需要任何操作，不必关系对象的释放。