3. 设计模式

（二）组合型模式

7. 适配器模式——不兼容结构的协调

1. 适配器模式（Adapter Pattern）：将一个接口转换为客户希望的另一个接口，使接口不兼容的那些类可以一起工作。

2. 要点

   1. 适配器模式可分为对象适配器和类适配器。
   2. 对象适配器中，适配器与适配者之间是关联关系。
   3. 类适配器中，适配器与适配者之间是继承关系，使用频率更高。

3. 结构图

   1. 对象适配器
      

   2. 类适配器

4. 适用场景示例

   学校教务管理系统：需要对学生成绩进程排序和查找。已经开发了成绩操作接口ScoreOperation，在成绩操作接口中声明了排序方法sort(int [])和查找方法search(int[],int)。现决定重用之前的算法库中的快速排序类QuickSort和二分查找类BinarySearch。

5. 代码示例

   // ScoreOperation.h
   /**
    * @brief 成绩操作接口
    *
    */
   class ScoreOperation {
        
    public:
     virtual void sort(int* array, int len) = 0;
     virtual int search(int* array, int len, int key) = 0;
   };
   
   /**
    * @brief 成绩操作适配器
    *
    */
   class OperationAdapter : public ScoreOperation {
        
    private:
     CommonToolNS::QuickSort* sortObj;
     CommonToolNS::BinarySearch* searchObj;
   
    public:
     OperationAdapter() {
        
       sortObj = new CommonToolNS::QuickSort();
       searchObj = new CommonToolNS::BinarySearch();
     }
   
    public:
     void sort(int* array, int len) override;
     int search(int* array, int len, int key) override;
   };
   
   // ScoreOperation.cpp
   void OperationAdapter::sort(int* array, int len) {
        
     sortObj->quickSort(array, len);
     return;
   }
   
   int OperationAdapter::search(int* array, int len, int key) {
        
     int flag = searchObj->binarySearch(array, len, key);
     return flag;
   }
   
   // CommonTool.h
   class QuickSort {
        
    public:
     /**
      * @brief 快速排序
      *
      * @param array
      * @param len
      */
     void quickSort(int* array, int len);
   
    private:
     void sort(int* array, int p, int r);
     int partition(int* array, int p, int r);
     void swap(int* array, int i, int j);
   };
   
   class BinarySearch {
        
    public:
     /**
      * @brief 二分查找
      *
      * @param array
      * @param len
      * @param key
      * @return int
      */
     int binarySearch(int* array, int len, int key);
   };
   
   class Log {
        
    public:
     static void print(int* array, int len);
   };
   
   // CommonTool.cpp
   void QuickSort::quickSort(int* array, int len) {
        
     sort(array, 0, len - 1);
     return;
   }
   
   void QuickSort::sort(int* array, int p, int r) {
        
     int q = 0;
     if (p < r) {
        
       q = partition(array, p, r);
       sort(array, p, q - 1);
       sort(array, q + 1, r);
     }
     return;
   }
   
   int QuickSort::partition(int* array, int p, int r) {
        
     int x = array[r];
     int j = p - 1;
     for (int i = p; i <= r - 1; ++i) {
        
       if (array[i] <= x) {
        
         j++;
         swap(array, j, i);
       }
     }
     swap(array, j + 1, r);
     return j + 1;
   }
   
   void QuickSort::swap(int* array, int i, int j) {
        
     int t = array[i];
     array[i] = array[j];
     array[j] = t;
     return;
   }
   
   int BinarySearch::binarySearch(int* array, int len, int key) {
        
     int low = 0;
     int high = len - 1;
     while (low <= high) {
        
       int mid = (low + high) / 2;
       int midVal = array[mid];
       if (midVal < key) {
        
         low = mid + 1;
       } else if (midVal > key) {
        
         high = mid - 1;
       } else {
        
         return 1;
       }
     }
     return -1;
   }
   
   void Log::print(int* array, int len) {
        
     printf("array: ");
     for (int i = 0; i < len; ++i) {
        
       printf("%d ", array[i]);
     }
     printf("\n");
     return;
   }
   

6. 代码测试

   • 测试代码

     int main(int argc, char** argv) {
            
       printf("I'm Adapter Pattern!\n");
       // begin test
       int scores[] = {
            34, 54, 23, 100, 66, 23, 76, 89, 98};
       ScoreOperation* scoreOperation = new OperationAdapter();
     
       scoreOperation->sort(scores, 9);
     
       Log::print(scores, 9);
     
       printf("查找成绩为98的学生：");
       if (scoreOperation->search(scores