C++装饰模式，设计模式

装饰模式

给一个已经定义好的类添加新的职责，通过的情况会定义一个新类继承自定类，这样子会带来一个问题，通过继承的方式解决会使系统的复杂性变得更深，而Decorator提供了一种给类增加的职责的方法，不是通过继承实现的，而通过组合。

优点：（1）装饰类和被装饰类可以独立发展，而不会相互耦合。（2）装饰模式是继承关系的一个替代方案。（3）装饰模式可以动态地扩展一个实现类的功能。

缺点：对于装饰模式记住一点就足够了：多层的装饰是比较复杂的。

应用场景：

（1）需要扩展一个类的功能，或给一个类增加附加功能。

（2）需要动态地给一个对象增加功能，这些功能可以再动态地撤销。

（3）需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式

 

ConcreteComponent和Decorator需要有同样的接口，ConcreteComponent和Decorator要有着同一个共同的父类。通过接口图中的ConcreteComponent和Decorator有一个公共的基类，可以利用面向对象多态的思想来实现只要是Component类型的对象都可以提高修饰操作的类，这种情况下即使新建100个Component型别的类ConcreteComponent，都可以由Decorator一个类搞定。

Component是一个接口或者是抽象类，就是定义我们最核心的对象，也就是最原始的对

象。

ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，你要装饰的对象

Decorator 一般是一个抽象类，做什么用呢？实现接口或者抽象方法，它里面可不一定有抽象的方法呀，在它的属性里必然有一个变量指向Component抽象构件

 

具体装饰角色

ConcreteDecorator是个具体的装饰类，你要把你最核心的、最原始的、最基本的东西装饰成其他东西

具体的实现例子

class Component

{

public:

         Component() {};

         ~Component() {}

         virtual void Operation();

protected:

private:

};

 

 

class ConcreteComponent :public Component

{

public:

         ConcreteComponent() {};

         ~ConcreteComponent() {};

         void Operation();

protected:

private:

 

};

 

class Decorator : public Component

{

public:

         Decorator(Component *pCom);

         ~Decorator();

         void Operation();

protected:

         Component *m_pCom;

private:

};

 

class ConcreteDecoratorOne :public Decorator

{

public:

         ConcreteDecoratorOne(Component *pCom);

         ~ConcreteDecoratorOne();

         void Operation();

         void AddedBehavion();

protected:

private:

};

 

class ConcreteDecoratorTwo :public Decorator

{

public:

         ConcreteDecoratorTwo(Component *pCom);

         ~ConcreteDecoratorTwo();

         void Operation();

         void AddedBeHavion();

protected:

private:

};

 

实现

#include "Decorator.h"

#include <iostream>

using namespace std;

void Component::Operation()

{

 

}

 

void ConcreteComponent::Operation()

{

         std::cout << "ConcreteComponent Operation..." << std::endl;

}

 

Decorator::Decorator(Component *pCom)

{

         this->m_pCom = pCom;

}

 

Decorator::~Decorator()

{

         if (m_pCom)

         {

                   delete m_pCom;

                   m_pCom = nullptr;

         }

}

 

void Decorator::Operation()

{

 

}

 

ConcreteDecoratorOne::ConcreteDecoratorOne(Component *pCom):Decorator(pCom)

{

 

}

 

ConcreteDecoratorOne::~ConcreteDecoratorOne()

{

 

}

 

void ConcreteDecoratorOne::Operation()

{

         m_pCom->Operation();

         this->AddedBehavion();

}

 

void ConcreteDecoratorOne::AddedBehavion()

{

         std::cout << "ConcreteDecorator::AddedBehavion...."<<std::endl;

}

 

ConcreteDecoratorTwo::ConcreteDecoratorTwo(Component *pCom):Decorator(pCom)

{

 

}

 

ConcreteDecoratorTwo::~ConcreteDecoratorTwo()

{

 

}

 

void ConcreteDecoratorTwo::Operation()

{

         m_pCom->Operation();

         this->AddedBeHavion();

}

 

void ConcreteDecoratorTwo::AddedBeHavion()

{

         std::cout << "ConcreteDecoratorTwo::AddedBeHavion...." << std::endl;

}

 

#include "Decorator.h"

int main(int argc, char* argv[])

{

         Component *pCom = new ConcreteComponent();

         Decorator *pDecOne = new ConcreteDecoratorOne(pCom);

         pDecOne->Operation();

         Decorator *pDecTwo = new ConcreteDecoratorTwo(pCom);

         pDecTwo->Operation();

         delete pDecOne;

         delete pDecTwo;

         return 0;

}