我与C++设计模式（八）——组合模式

最新推荐文章于 2024-11-02 18:40:34 发布

原创最新推荐文章于 2024-11-02 18:40:34 发布 · 456 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++ #设计模式 #composite

设计模式专栏收录该内容

22 篇文章

订阅专栏

本文深入探讨组合模式，一种解决整体与部分一致性操作需求的设计模式。通过定义抽象组件类，允许同时处理整体与部分对象，实现统一的接口访问。详细展示了组件和叶节点的实现方式，以及如何在实际代码中应用组合模式，最终演示了遍历和访问对象的效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

组合模式又是一个稍微简单一点的模式，不是说内容简单，就是逻辑上好理解，就比上一篇的decorator，一开始很纠结，为啥叫装饰者，为啥要继承还内含一个父类指针，这里就相对来说容易一些。

组合模式，是为了解决整体和部分一直对待的问题而产生的，要求整体和部分有很多一致的操作。部分和整体继承同一个抽象几口，这样，外部使用时是一致的，同一个方法能遍历整体也能访问部分。

代码：

#ifndef _COMPOSITE_H__
#define _COMPOSITE_H__

#include <vector>
using namespace std;

class component
{
        public:
                component();
                virtual ~component();

                virtual void operation() = 0;
                virtual void add(component*);
                virtual component* get_child(int);
};

class leaf:public component
{
        public:
                leaf();
                ~leaf();

                void operation();
};

class composite:public component
{
        public:
                composite();
                ~composite();

                void operation();
                void add(component*);
                component* get_child(int);

        private:
                vector<component*> p_com_vec;
};
#endif

//composite.cpp

#include <iostream>
#include "composite.h"
using namespace std;

component::component()
{
}

component::~component()
{
}

void component::add(component *p_com)
{
}

component *component::get_child(int index)
{
        return NULL;
}


leaf::leaf()
{
}

leaf::~leaf()
{
}

void leaf::operation()
{
        cout<<"operation from leaf"<<endl;
}


composite::composite()
{
}

composite::~composite()
{
}

void composite::operation()
{
        cout<<"operation from composite"<<endl;
        vector<component*>::iterator com_ite = p_com_vec.begin();

        for ( ; com_ite != p_com_vec.end(); ++com_ite)
        {
                (*com_ite)->operation();
        }
}

void composite::add(component *p_com)
{
        p_com_vec.push_back(p_com);
}


component* composite::get_child(int index)
{
        return p_com_vec[index];
}

#include "composite.h"

int main(int argc,char **argv)
{
        leaf *p_le = new leaf();
        p_le->operation();

        composite* p_com = new composite();
        p_com->add(p_le);
        p_com->operation();

        component * p_con = p_com->get_child(0);
        p_con->operation();

        return 0;
}

$ g++ -o composite main.cpp composite.cpp

结果：

operation from leaf
operation from composite
operation from leaf
operation from leaf