基本概念

(1)装饰模式(Decorator)：动态地给对象添加一些额外的职责，就增加功能来说装饰模式比生成子类更为灵活；

(2)Component：定义一个接口对象，可以对这些对象动态地添加职责；

(3)ConcreteComponent:定义一个具体的对象，也可以对这些对象添加一些职责；

(4)Decorator:装饰抽象类，继承了Component，从外类来扩展Compenent 类的功能；

(5)ConereteDecorator:具体的装饰对象，可以有多个(ConereteDecoratorA、ConereteDecorator B…)，起到给Component添加职责的功能。

(6)如果只有一个ConcreteComponent类而没有抽象的Component类那可以将Decorator设计为ConcreteComponent的子类，同理若ConereteDecorator只有一个类，那没必要建立 Decorator类，可以吧ConereteDecorator和Decorator类合并。

具体实现(VS,C++)

//#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<algorithm>
#include<xfunctional>
using namespace std;


class Component
{
public:
	Component();
	~Component();
	virtual void Operation() = 0;
private:

};
class ConcreteComponent:public Component
{
public:
	ConcreteComponent();
	~ConcreteComponent();
	void Operation() {
		cout << "ConcreteComponent:具体对象的操作" << endl;
	}
private:

};

class Decorator:public Component
{
public:

	// 通过构造函数传递给被修饰者
	Decorator(Component *component) {
		this->component = component;
	}

	// 委托给被修饰者执行
	void Operation() {
		if (component != nullptr) {
			this->component->Operation();
		}

	}
	Decorator();
	~Decorator();

private:
	Component *component = nullptr;

};


class ConcreteDecoratorA:public Decorator
{
public:
	ConcreteDecoratorA();
	~ConcreteDecoratorA();

	//定义被修饰者
	ConcreteDecoratorA(Component *component) {
		super1 = component;
	}

	//定义自己的修饰方法
	void behavior1() {
		cout << "behavior1:第一次修饰" << endl;
	}

	void Operation() {
		super1->Operation();
		this->behavior1();
	}

private:
	Component *super1;
};

class ConcreteDecoratorB:public Decorator
{
public:
	ConcreteDecoratorB();
	~ConcreteDecoratorB();
	//定义被修饰者
	ConcreteDecoratorB(Component *component) {
		super2 = component;
	}

	// 定义自己的修饰方法
	void behavior2() {
		cout << "behavior2:第二次修饰" << endl;
	}

	void Operation() {
		super2->Operation();
		this->behavior2();
	}


private:
	Component *super2 = nullptr;


};

ConcreteDecoratorB::ConcreteDecoratorB()
{
}

ConcreteDecoratorB::~ConcreteDecoratorB()
{
	delete super2;
}

ConcreteDecoratorA::ConcreteDecoratorA()
{
}

ConcreteDecoratorA::~ConcreteDecoratorA()
{
	delete super1;
}


Decorator::Decorator()
{
}

Decorator::~Decorator()
{
	delete component;
}


Component::Component()
{
}

Component::~Component()
{
}
ConcreteComponent::ConcreteComponent()
{
}

ConcreteComponent::~ConcreteComponent()
{
}

int main(int argc, char** argv)
{
	Component *component = new ConcreteComponent();
	component = new ConcreteDecoratorA(component);
	component = new ConcreteDecoratorB(component);
	component->Operation();

	return 0;
}

具体案例(VS,C++)

//#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<string>
using namespace std;

class Person
{
public:
	Person();
	~Person();
	Person(string name) {
		this->name = name;
	}
	virtual void show() {
		cout << "被装饰人：" << name << endl;
	}
private:
	string name;
};

class Finery:public Person
{
public:
	Finery();
	~Finery();
	Finery(Person *person) {
		this->person = person;

	}
	void show() {
		if (person != nullptr) {
			person->show();
		}

	}
private:
	Person *person;
};

class TShirts:public Finery
{
public:
	TShirts();
	~TShirts();
	TShirts(Person* per) {
		this->per = per;
	}

	void show() {
		per->show();
		cout << "大 T 恤" << endl;
	}

private:
	Person* per;

};

class BigTrouser:public Finery
{
public:
	BigTrouser();
	~BigTrouser();
	BigTrouser(Person *per) {
		this->per = per;

	}
	void show() {
		per->show();
		cout << "短裤" << endl;
	}

private:
	Person *per;

};

BigTrouser::BigTrouser()
{
}

BigTrouser::~BigTrouser()
{
}

TShirts::TShirts()
{
}

TShirts::~TShirts()
{
	delete per;
}

Finery::Finery()
{
}

Finery::~Finery()
{
	delete person;
}

Person::Person()
{
}

Person::~Person()
{
}


int main(int argc, char** argv)
{
	Person *dog = new Person("Bob");
	dog = new TShirts(dog);
	dog = new BigTrouser(dog);
	dog->show();

	delete dog;
	return 0;
}

关于作者

长期从事编程相关研究，涉及Qt、机械臂、轮式机器人、四足机器人的建模及仿真，可共同探讨编程相关问题，可指导课程设计及毕业设计，详询：QQ:2963325158