【C++设计模式之Decorator装饰模式】

---

前言

在软件组件的设计中，如果责任划分的不清楚，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。

模式定义

Decorator装饰模式：动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类(继承)更为灵活(消除重复代码&减少子类个数)。

允许通过将对象包装在装饰器类中，动态地为对象添加额外的功能。该模式通过组合而非继承来扩展对象的行为，避免因多重继承导致的类爆炸问题。

动机(Motivation)

• 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多(扩展功能的增多)，各种子类的组合(扩展功能的组合)会导致更多子类的膨胀。
• 如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响将为最低？

结构

核心思想

• 动态扩展： 运行时为对象添加功能，而非编译时。
• 透明性： 装饰后的对象与原始对象接口一致，对客户端透明。
• 组合优于继承： 通过嵌套装饰器实现功能的灵活叠加。

基础实现

1、定义组件接口

#include"component.h"

#pragma once
class Component {
	//抽象的构件
public:
	virtual void operate() = 0;
};

2、实现具体组件(被修饰对象)

concretecomponent.h

#pragma once
#include<iostream>
#include"component.h"
class ConcreteComponent :public Component {
public:
	void operate()override {
		std::cout << "ConcreteComponent do Something";
	}
};

3、定义装饰器基类

decorator.h

#pragma once
#include"component.h"

class Decorator :public Component {
	//通过构造函数传递被修饰者
public:
	Decorator(Component*component) {
		component_ = component;
	}

	//委托给被修饰者执行
	void operate() override {

	}
private:
	Component*component_ = nullptr;
};

4、实现具体装饰器

concretedecorator.h

#pragma once
#include<iostream>
#include"decorator.h"
class ConcreteDecorator1 :public Decorator {
public:
	ConcreteDecorator1(Component*component) :Decorator(component) {

	}

	//重写父类的Operation方法
	void operate()override {
		method1();
		Decorator::operate();
	}
private:
	//定义自己的修饰方法
	void method1() {
		std::cout << "method1 of Decorator1";
	}
};


class ConcreteDecorator2 : public Decorator {
public:
	ConcreteDecorator2(Component *component)
		: Decorator(component) {
	}
	//重写父类的Operation方法
	void operate() override {
		method1();
		Decorator::operate();
	}
private:
	//定义自己的修饰方法
	void method1() {
		std::cout << "method1 of Decorator2";
	}
};

5、使用示例

#include <iostream>
#include"concretecomponent.h"
#include"concretedecorator.h"

int main()
{
	Component*component = new ConcreteComponent();

	//第一次修饰
	component = new ConcreteDecorator1(component);
	//第二次修饰
	component = new ConcreteDecorator2(component);
	//修饰后运行
	component->operate();
}

模式应用（具体应用）

1、定义组件接口(应用)

component1.h

#pragma once
#include<iostream>
#include<memory>
#include<string>

//抽象组件：定义基础功能接口
class Beverage {
public:
	virtual ~Beverage() = default;
	virtual std::string getDescription()const = 0;    //获取描述
	virtual double cost()const = 0;                   //计算价格
};

2、实现具体组件(被修饰对象)

concretecomponent1.h

#pragma once
//具体组件：基础咖啡
#include"component1.h"

class Coffee :public Beverage {
public:
	std::string getDescription()const override {
		return "coffee";
	}

	double cost()const override {
		return 20.0;
	}
};

3、定义装饰器基类

decorator1

#pragma once
//装饰器基类：继承自组件接口，并持有组件对象的引用
#include"component1.h"
#include<memory>
class CondimentDecorator :public Beverage {
protected:
	std::unique_ptr<Beverage> beverage_;     //被装饰的组件

public:
	explicit CondimentDecorator(std::unique_ptr<Beverage>beverage)
		:beverage_(std::move(beverage)){}
};

4、实现具体装饰器

concretedecorator1.h

#pragma once

#include"decorator1.h"
//具体装饰器：加糖
class Sugar :public CondimentDecorator {
public:
	using CondimentDecorator::CondimentDecorator;
	std::string getDescription()const override {
		return beverage_->getDescription() + "+ 糖";
	}

	double cost() const override {
		return beverage_->cost() + 2.0;      //糖的价格增加2元
	}
};

//具体装饰器：加牛奶
class Milk :public CondimentDecorator {
public:
	using CondimentDecorator::CondimentDecorator;
	std::string getDescription()const override {
		return beverage_->getDescription() + " + 牛奶";
	}

	double cost() const override {
		return beverage_->cost() + 5.0;     //牛奶增加五元
	}
};

5、使用示例

#include"concretedecorator1.h"
#include"concretecomponent1.h"
#include"decorator1.h"
#include<memory>

int main()
{
	//创建基类咖啡
	auto coffee = std::make_unique<Coffee>();
	std::cout << "订单： " << coffee->getDescription()
		<< " , 价格： " << coffee->cost() << "元\n";


	//动态添加装饰：先加糖，再加牛奶
	std::unique_ptr<Beverage>  decoratedCoffee = std::make_unique<Sugar>(std::move(coffee));
	decoratedCoffee = std::make_unique<Milk>(std::move(decoratedCoffee));
	std::cout << "订单： " << decoratedCoffee->getDescription()
		<< " , 总价： " << decoratedCoffee->cost() << "元\n";
}

输出结果

订单： coffee , 价格： 20元
订单： coffee+ 糖 + 牛奶 , 总价： 27元

要点总结

• 通过采用组合而非继承的手法， Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。
• Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
• Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。