23种设计模式之C++实践（二）

5436649486

已于 2023-12-10 19:47:24 修改

阅读量1.1k

点赞数 17

分类专栏： C++ 文章标签：设计模式 c++

于 2023-12-03 10:22:42 首次发布

本文链接：https://blog.csdn.net/weixin_50749380/article/details/134721784

版权

本文详细介绍了C++中的四种设计模式：适配器模式，包括类适配器和双向适配器；组合模式，探讨透明组合和安全组合；装饰模式的应用；以及外观模式的总结。这些模式在处理对象间接口不兼容、树形结构、扩展系统功能和提供统一入口方面起着关键作用。

摘要由CSDN通过智能技术生成

3. 设计模式

（二）组合型模式

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

适配器模式（Adapter Pattern）：将一个接口转换为客户希望的另一个接口，使接口不兼容的那些类可以一起工作。
要点
1. 适配器模式可分为对象适配器和类适配器。
2. 对象适配器中，适配器与适配者之间是关联关系。
3. 类适配器中，适配器与适配者之间是继承关系，使用频率更高。
结构图
1. 对象适配器
2. 类适配器
适用场景示例

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

代码示例

// 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;
}

代码测试

测试代码

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, 9, 98) == 1) {
       
    printf("找到\n");
  } else {
       
    printf("未找到\n");
  }

  printf("查找成绩为99的学生：");
  if (scoreOperation->search(scores,