• 设计模式-组合模式-笔记


    “数据结构”模式

    常常有一些组件在内部具有特定的数据结构,如果让客户程序依赖这些特定数据结构,将极大地破坏组件的复用。这时候,将这些特定数据结构封装在内部,在外部提供统一的接口,来实现与特定数据结构无关的访问,是一种行之有效的解决方案。

    经典模式:Composite、Iterator、Chain of resposibility

    动机(Motivation)

    将对象组合成树形结构以代表“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性(稳定)。

    示例:

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5. class Component {
    6. public:
    7. virtual void process() = 0;
    8. virtual ~Component() {}
    9. };
    10. //树节点
    11. class Composite : public Component {
    12. string name_;
    13. list elements_;
    14. public:
    15. Composite(const string& s) : name_(s) {}
    16. void add(Component* element) {
    17. elements_.push_back(element);
    18. }
    19. void remove(Component* element) {
    20. elements_.remove(element);
    21. }
    22. void process() override {
    23. //1.process curent node
    24. //2.process leaf nodes
    25. for (auto& e : elements_){
    26. e->process(); //虚函数调用,多态调用
    27. }
    28. }
    29. };
    30. //叶子节点
    31. class Leaf : public Component {
    32. string name_;
    33. public:
    34. Leaf(const string&s) : name_(s) {}
    35. void process() override {
    36. //process current node
    37. }
    38. };
    39. //客户程序
    40. void invoke(Component& c) {
    41. //...
    42. c.process();
    43. //...
    44. }
    45. int main() {
    46. Composite root("root");
    47. Composite treeNode1("treeNode1");
    48. Composite treeNode2("treeNode2");
    49. Composite treeNode3("treeNode3");
    50. Composite treeNode4("treeNode4");
    51. Leaf leaf1("leaf1");
    52. Leaf leaf2("leaf2");
    53. root.add(&treeNode1);
    54. treeNode1.add(&treeNode2);
    55. treeNode2.add(&leaf1);
    56. root.add(&treeNode3);
    57. treeNode3.add(&treeNode4);
    58. treeNode4.add(&leaf2);
    59. invoke(root);
    60. invoke(leaf2);
    61. invoke(treeNode3);
    62. }

    要点总结:

    Composite模式采用采用树形结构来实现普遍存在的对象容器,从而将“一对多”的关系转化为“一对一”的关系,使得客户代码可以一致地(复用)处理对象和对象容器,无需关系处理的是单个的对象,还是组合的对象容器。

    将“客户代码与复杂的对象容器结构”解耦是Composite的核心思想,解耦之后,客户代码将与纯粹的抽象接口----而非对象容器的内部实现结构----发生依赖,从而更能”应对变化”。

    COmposite模式在具体实现中,可以让父对象中的子对象反向追溯;如果父对象有频繁的遍历需求,可使用缓存技巧来改善效率。

  • 相关阅读:
    ES6类和继承
    CMU15445-project2-坑和收获总结
    java设计模式7,工厂方法模式 | 文末送《Java核心技术》第12版
    Android 多线程、线程池
    Codeforces Round #787 (Div. 3) F. Vlad and Unfinished Business
    OpenCV DNN 活体检测项目环境配置等各阶段tips
    2022高教社杯数学建模比赛论文资料1.0
    探索Docker:原理、安装与基础应用
    前置知识--Quartz
    学习笔记-Flutter 布局控件完结篇
  • 原文地址:https://blog.csdn.net/zhaodongdong2012/article/details/134495881