装饰器模式

1 装饰器模式的基本概念
在 C++ 中，装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更为灵活，它可以在不修改现有类结构的情况下增加新的功能。

装饰器模式的基本概念包括：

（1）组件（Component）： 这是一个接口或抽象类，定义了对象的核心功能。装饰器模式和组件一起工作，允许组件被装饰。

（2）具体组件（Concrete Component）： 实现了组件接口或抽象类的具体类。它是被装饰的对象。

（3）装饰器（Decorator）： 这是一个接口或抽象类，继承自组件接口，并持有一个组件对象的引用。装饰器允许在运行时向组件添加职责。

（4）具体装饰器（Concrete Decorator）： 实现了装饰器接口或抽象类的具体类。它给组件添加额外的功能。

在 C++ 中，装饰器模式通常通过继承和接口实现。具体装饰器类会继承装饰器基类，并在其方法中实现对组件的调用以及额外的功能。装饰器对象会持有一个组件对象的引用，并在其方法中将其传递给其他装饰器或具体组件。

2 装饰器模式的实现步骤
在C++中实现装饰器模式通常涉及以下步骤：

（1）定义组件接口：
首先，定义一个接口或抽象基类，它声明了将被装饰对象应有的核心功能。这个接口是装饰器模式中的关键部分，因为它允许装饰器和组件对象以统一的方式工作。

（2）实现具体组件：
接下来，创建实现了组件接口的具体类。这些类通常包含实际要执行的操作。

（3）创建装饰器接口：
装饰器接口或抽象基类继承自组件接口。它持有一个指向组件对象的引用，并且通常会提供一个构造函数，允许在创建装饰器对象时传入一个组件对象。

（4）实现具体装饰器：
具体装饰器类实现了装饰器接口，并且可以在其操作中添加额外的功能，同时调用组件对象上的操作。通过这种方式，装饰器可以在运行时动态地增强组件的功能。

（5）使用装饰器：
最后，客户端代码创建组件对象，并使用装饰器来增强它们的功能。这可以通过简单地创建装饰器对象并将组件对象作为参数传递来实现。装饰器可以嵌套使用，从而允许添加多个额外的功能。

下面是一个简单的装饰器模式实现示例：

#include <iostream>  
#include <memory>  

// 步骤 1: 定义组件接口  
class Component {
public:
	virtual void operation() = 0;
	virtual ~Component() = default;
};

// 步骤 2: 实现具体组件  
class ConcreteComponent : public Component {
public:
	void operation() override {
		std::cout << "ConcreteComponent operation" << std::endl;
	}
};

// 步骤 3: 创建装饰器接口  
class Decorator : public Component {
public:
    //并且通常会提供一个构造函数，允许在创建装饰器对象时传入一个组件对象
	explicit Decorator(std::unique_ptr<Component> comp) : component(std::move(comp)) {}

	void operation() override {
		if (component != nullptr) {
            //调用组件的函数
			component->operation();
		}
	}

protected:
    //它持有一个指向组件对象的引用
	std::unique_ptr<Component> component;
};

// 步骤 4: 实现具体装饰器  
class ConcreteDecoratorA : public Decorator {
public:
	explicit ConcreteDecoratorA(std::unique_ptr<Component> comp) : Decorator(std::move(comp)) {}

	void operation() override 
    {
        //可以在之前/后添加A类的操作
		std::cout << "ConcreteDecoratorA operation" << std::endl;
		Decorator::operation();//调用抽象装饰器的操作
	}
};

class ConcreteDecoratorB : public Decorator {
public:
	explicit ConcreteDecoratorB(std::unique_ptr<Component> comp) : Decorator(std::move(comp)) {}

	void operation() override 
    {
        //调用抽象装饰器的操作
		Decorator::operation();
        //可以在之后/后添加B类的操作
		std::cout << "ConcreteDecoratorB operation" << std::endl;
	}
};

// 步骤 5: 使用装饰器  
int main() 
{
	// 创建组件对象并使用智能指针管理  
	std::unique_ptr<Component> component = std::make_unique<ConcreteComponent>();

	// 使用装饰器增强组件，并传递智能指针  
	component = std::make_unique<ConcreteDecoratorA>(std::move(component));
	component = std::make_unique<ConcreteDecoratorB>(std::move(component));

	// 执行操作  
	component->operation();

	// 智能指针会自动管理内存，无需手动删除  

	return 0;
}

                        
原文链接：https://blog.csdn.net/h8062651/article/details/136495783