设计模式-装饰器模式

lykhahaha2023-11-24 19:15

基础概念介绍

代码实现

基础模式
基础模式实现一

如果不使用装饰器模式，而是采用最普遍的类继承和组合的方式，我们需要直接在每个具体类中添加新的功能。这可能导致类的层次结构变得复杂，难以维护，因为每个具体类都需要预先知道所有可能的组合方式。

下面是一个简化的示例，演示了使用类继承和组合的方式来实现相同的功能：

coffee_simple.hpp (头文件)

cpp 复制代码 
#ifndef COFFEE_SIMPLE_HPP
#define COFFEE_SIMPLE_HPP

#include <iostream>
#include <string>

// 基础咖啡类
class SimpleCoffeeSimple {
public:
    std::string getDescription() const {
        return "Simple Coffee";
    }

    double cost() const {
        return 1.0;
    }
};

// 咖啡加牛奶类
class CoffeeWithMilkSimple {
    SimpleCoffeeSimple baseCoffee;

public:
    std::string getDescription() const {
        return baseCoffee.getDescription() + ", Milk";
    }

    double cost() const {
        return baseCoffee.cost() + 0.5;
    }
};

// 咖啡加牛奶和糖类
class CoffeeWithMilkAndSugarSimple {
    CoffeeWithMilkSimple baseCoffee;

public:
    std::string getDescription() const {
        return baseCoffee.getDescription() + ", Sugar";
    }

    double cost() const {
        return baseCoffee.cost() + 0.2;
    }
};

#endif // COFFEE_SIMPLE_HPP

main_simple.cpp (主函数调用)

cpp 复制代码 
#include "coffee_simple.hpp"

int main() {
    SimpleCoffeeSimple simpleCoffee;
    std::cout << "Description: " << simpleCoffee.getDescription() << ", Cost: $" << simpleCoffee.cost() << std::endl;

    CoffeeWithMilkSimple coffeeWithMilk;
    std::cout << "Description: " << coffeeWithMilk.getDescription() << ", Cost: $" << coffeeWithMilk.cost() << std::endl;

    CoffeeWithMilkAndSugarSimple coffeeWithMilkAndSugar;
    std::cout << "Description: " << coffeeWithMilkAndSugar.getDescription() << ", Cost: $" << coffeeWithMilkAndSugar.cost() << std::endl;

    return 0;
}

这个简单的例子中，我们创建了基础的咖啡类 SimpleCoffeeSimple，以及添加了牛奶和糖的两个具体类。每个类中都包含了 getDescription 和 cost 函数，用于描述咖啡的属性和计算成本。

基础模式实现二

coffee_no_decorator.hpp (头文件)

cpp 复制代码 
#ifndef COFFEE_NO_DECORATOR_HPP
#define COFFEE_NO_DECORATOR_HPP

#include <iostream>
#include <string>

// Component（组件）：定义一个对象接口，可以动态地给该对象添加一些职责
class CoffeeNoDecorator {
public:
    virtual ~CoffeeNoDecorator() = default;
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
    virtual void serve() const {
        std::cout << "Serving " << getDescription() << " coffee." << std::endl;
    }
};

// 具体组件：SimpleCoffee
class SimpleCoffeeNoDecorator : public CoffeeNoDecorator {
public:
    std::string getDescription() const override {
        return "Simple Coffee";
    }

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

// 调料组合类：CoffeeWithMilkAndSugar
class CoffeeWithMilkAndSugarNoDecorator : public CoffeeNoDecorator {
    SimpleCoffeeNoDecorator baseCoffee;

public:
    std::string getDescription() const override {
        return baseCoffee.getDescription() + ", Milk, Sugar";
    }

    double cost() const override {
        return baseCoffee.cost() + 0.5 + 0.2;
    }
};

#endif // COFFEE_NO_DECORATOR_HPP

coffee_no_decorator.cpp (类实现)

cpp 复制代码 
#include "coffee_no_decorator.hpp"
// 没有新的功能需要添加，因此这里的实现相对简单

main_no_decorator.cpp (主函数调用)

cpp 复制代码 
#include "coffee_no_decorator.hpp"

int main() {
    // 基础咖啡
    CoffeeNoDecorator* simpleCoffee = new SimpleCoffeeNoDecorator();
    simpleCoffee->serve();
    delete simpleCoffee;

    // 咖啡加牛奶和糖
    CoffeeNoDecorator* sugarMilkCoffee = new CoffeeWithMilkAndSugarNoDecorator();
    sugarMilkCoffee->serve();
    delete sugarMilkCoffee;

    return 0;
}

CMakeLists_no_decorator.txt

cpp 复制代码 
cmake_minimum_required(VERSION 3.10)

project(CoffeeNoDecoratorPattern)

# 添加头文件目录
include_directories(${CMAKE_SOURCE_DIR})

# 添加可执行文件
add_executable(coffee_no_decorator main_no_decorator.cpp coffee_no_decorator.cpp)

# 指定C++标准
set(CMAKE_CXX_STANDARD 11)

# 指定生成目标链接的库
target_link_libraries(coffee_no_decorator)

在这个实现中，我们创建了两个类：SimpleCoffeeNoDecorator 表示基础咖啡，CoffeeWithMilkAndSugarNoDecorator 表示加了牛奶和糖的咖啡。这两个类通过继承和组合来实现不同组合的咖啡。

通过比较装饰器模式和不使用装饰器模式的实现：

使用装饰器模式的优点：

灵活性和可扩展性： 装饰器模式允许动态地组合各种功能，而不影响原始类的结构。新功能可以轻松添加，而不需要修改现有代码。

遵循开闭原则： 装饰器模式使得系统更容易扩展，避免了通过继承创建复杂的类层次结构。

不使用装饰器模式的劣势：
类层次结构复杂： 不使用装饰器模式可能导致类层次结构的复杂性增加，特别是在有多个组合的情况下。

类的修改： 如果需要添加新的功能，可能需要直接修改现有的类，这违反了开闭原则，可能导致系统更难维护和扩展。

总体来说，使用装饰器模式能够更好地满足开闭原则，提高代码的灵活性和可维护性。

装饰器模式改进
简单装饰器模式

coffee.hpp (头文件)

cpp 复制代码 
#ifndef COFFEE_HPP
#define COFFEE_HPP

#include <iostream>
#include <string>

// Component（组件）：定义一个对象接口，可以动态地给该对象添加一些职责
class Coffee {
public:
    virtual ~Coffee() = default;
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
};

// ConcreteComponent（具体组件）：定义一个具体的对象，也可以给这个对象添加一些职责
class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override {
        return "Simple Coffee";
    }

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

// Decorator（装饰器）：维持一个指向Component对象的指针，并定义一个与Component接口一致的接口
class CoffeeDecorator : public Coffee {
protected:
    Coffee* coffee;

public:
    CoffeeDecorator(Coffee* c) : coffee(c) {}

    std::string getDescription() const override {
        return coffee->getDescription();
    }

    double cost() const override {
        return coffee->cost();
    }
};

// ConcreteDecorator（具体装饰器）：具体的装饰器，向组件添加职责
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(Coffee* c) : CoffeeDecorator(c) {}

    std::string getDescription() const override {
        return coffee->getDescription() + ", Milk";
    }

    double cost() const override {
        return coffee->cost() + 0.5;
    }
};

class SugarDecorator : public CoffeeDecorator {
public:
    SugarDecorator(Coffee* c) : CoffeeDecorator(c) {}

    std::string getDescription() const override {
        return coffee->getDescription() + ", Sugar";
    }

    double cost() const override {
        return coffee->cost() + 0.2;
    }
};

#endif // COFFEE_HPP

coffee.cpp (类实现)

cpp 复制代码 
#include "coffee.hpp"

// 可以在这里添加额外的实现，但在这个例子中，我们的类已经足够简单，无需额外的实现。

main.cpp (主函数调用)

cpp 复制代码 
#include "coffee.hpp"

int main() {
    Coffee* myCoffee = new SimpleCoffee();
    std::cout << "Description: " << myCoffee->getDescription() << ", Cost: $" << myCoffee->cost() << std::endl;

    myCoffee = new MilkDecorator(myCoffee);
    std::cout << "Description: " << myCoffee->getDescription() << ", Cost: $" << myCoffee->cost() << std::endl;

    myCoffee = new SugarDecorator(myCoffee);
    std::cout << "Description: " << myCoffee->getDescription() << ", Cost: $" << myCoffee->cost() << std::endl;

    delete myCoffee;

    return 0;
}

这种组织方式将代码拆分为头文件、类实现和主函数调用的三个部分，更符合典型的C++项目结构，使代码更易读、易维护。如果项目规模增大，可以更方便地管理和扩展。

当你组织了多个源文件时，CMakeLists.txt 文件会有所变化。以下是修改后的 CMakeLists.txt 文件，适用于这个多文件的示例：

CMakeLists.txt

cpp 复制代码 
cmake_minimum_required(VERSION 3.10)
project(CoffeeDecoratorPattern)
# 添加头文件目录
include_directories(${CMAKE_SOURCE_DIR})
# 添加可执行文件
add_executable(coffee_decorator main.cpp coffee.cpp)
# 指定C++标准
set(CMAKE_CXX_STANDARD 11)
# 指定生成目标链接的库
target_link_libraries(coffee_decorator)

在这个 CMakeLists.txt 文件中，我使用 include_directories(${CMAKE_SOURCE_DIR}) 添加了头文件目录，确保 CMake 可以找到 coffee.hpp 头文件。然后，我使用 add_executable 命令将 main.cpp 和 coffee.cpp 编译成一个可执行文件 coffee_decorator。

要编译和运行代码，你可以按照之前提供的步骤进行。在包含代码和 CMakeLists.txt 文件的目录中，执行以下命令：

bash 复制代码 
mkdir build  # 创建一个build目录用于存放生成的文件
cd build     # 进入build目录
# 使用CMake生成Makefile
cmake ..
# 使用Make编译项目
make
# 运行生成的可执行文件
./coffee_decorator
复杂装饰器模式

当使用装饰器模式时，我们的目标是在不修改基础类的情况下，动态地添加功能。为了更好地说明这一点，我们将考虑一个更实际的场景，例如咖啡馆系统，其中 SimpleCoffee 表示基础咖啡，而装饰器用于添加额外的功能，比如添加调料、改变咖啡温度等。

coffee.hpp (头文件)

cpp 复制代码 
#ifndef COFFEE_HPP
#define COFFEE_HPP

#include <iostream>
#include <string>

// Component（组件）：定义一个对象接口，可以动态地给该对象添加一些职责
class Coffee {
public:
    virtual ~Coffee() = default;
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
    virtual void serve() const {
        std::cout << "Serving " << getDescription() << " coffee." << std::endl;
    }
};

// ConcreteComponent（具体组件）：定义一个具体的对象，也可以给这个对象添加一些职责
class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override {
        return "Simple Coffee";
    }

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

// Decorator（装饰器）：维持一个指向Component对象的指针，并定义一个与Component接口一致的接口
class CoffeeDecorator : public Coffee {
protected:
    Coffee* coffee;

public:
    CoffeeDecorator(Coffee* c) : coffee(c) {}

    std::string getDescription() const override {
        return coffee->getDescription();
    }

    double cost() const override {
        return coffee->cost();
    }
};

// 具体装饰器类，比如调料
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(Coffee* c) : CoffeeDecorator(c) {}

    std::string getDescription() const override {
        return coffee->getDescription() + ", Milk";
    }

    double cost() const override {
        return coffee->cost() + 0.5;
    }
};

class SugarDecorator : public CoffeeDecorator {
public:
    SugarDecorator(Coffee* c) : CoffeeDecorator(c) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Sugar";
    }
    double cost() const override {
        return coffee->cost() + 0.2;
    }
};

#endif // COFFEE_HPP

coffee.cpp (类实现)

cpp 复制代码 
#include "coffee.hpp"

// 具体的装饰器类，比如调整咖啡温度的装饰器
class TemperatureDecorator : public CoffeeDecorator {
public:
    TemperatureDecorator(Coffee* c) : CoffeeDecorator(c) {}

    std::string getDescription() const override {
        return coffee->getDescription() + ", Hot";
    }

    double cost() const override {
        return coffee->cost() + 0.3;
    }

    void serve() const override {
        std::cout << "Serving " << getDescription() << " coffee." << std::endl;
    }
};

// 具体的装饰器类，比如添加奶泡的装饰器
class FoamDecorator : public CoffeeDecorator {
public:
    FoamDecorator(Coffee* c) : CoffeeDecorator(c) {}

    std::string getDescription() const override {
        return coffee->getDescription() + ", Foam";
    }

    double cost() const override {
        return coffee->cost() + 0.4;
    }

    void serve() const override {
        std::cout << "Serving " << getDescription() << " coffee." << std::endl;
    }
};

// 具体的咖啡类，比如浓缩咖啡
class Espresso : public Coffee {
public:
    std::string getDescription() const override {
        return "Espresso";
    }
    double cost() const override {
        return 2.0;
    }
};

main.cpp (主函数调用)

cpp 复制代码 
#include "coffee.hpp"

int main() {
    // 基础咖啡
    Coffee* simpleCoffee = new SimpleCoffee();
    simpleCoffee->serve();
    delete simpleCoffee;

    // 咖啡加牛奶
    Coffee* milkCoffee = new MilkDecorator(new SimpleCoffee());
    milkCoffee->serve();
    delete milkCoffee;

    // 咖啡加牛奶和糖
    Coffee* sugarMilkCoffee = new SugarDecorator(new MilkDecorator(new SimpleCoffee()));
    sugarMilkCoffee->serve();
    delete sugarMilkCoffee;

    // 咖啡加糖、牛奶和泡沫，这里使用了温度装饰器和奶泡装饰器
    Coffee* complexCoffee = new FoamDecorator(new TemperatureDecorator(new SugarDecorator(new MilkDecorator(new SimpleCoffee()))));
    complexCoffee->serve();
    delete complexCoffee;

    // 浓缩咖啡，这里使用了温度装饰器和奶泡装饰器
    Coffee* espresso = new FoamDecorator(new TemperatureDecorator(new Espresso()));
    espresso->serve();
    delete espresso;

    return 0;
}

CMakeLists.txt

cpp 复制代码 
cmake_minimum_required(VERSION 3.10)
project(CoffeeDecoratorPattern)
# 添加头文件目录
include_directories(${CMAKE_SOURCE_DIR})
# 添加可执行文件
add_executable(coffee_decorator main.cpp coffee.cpp)
# 指定C++标准
set(CMAKE_CXX_STANDARD 11)
# 指定生成目标链接的库
target_link_libraries(coffee_decorator)

在这个例子中，我们引入了两个新的装饰器类：TemperatureDecorator（温度装饰器）和 FoamDecorator（奶泡装饰器），以及一个新的具体咖啡类 Espresso（浓缩咖啡）。这些类都实现了 Coffee 接口，通过装饰器模式，我们可以在运行时动态地为咖啡添加不同的功能，而无需修改原有代码。

通过对比简化例子和这个更复杂的例子，我们可以看到使用装饰器模式的优势，特别是在处理复杂组合的情况下。它使得系统更加灵活，易于扩展，同时遵循开闭原则。

使用装饰器模式的详细解释
  1. 基础咖啡类SimpleCoffee：
    • SimpleCoffee 是具体组件，实现了 Coffee 接口。
    • getDescription 返回 "Simple Coffee"，cost 返回基础咖啡的价格。
  2. 装饰器抽象类 CoffeeDecorator：
    • CoffeeDecorator 是装饰器的抽象基类，也实现了 Coffee 接口。
    • 拥有一个指向 Coffee 对象的指针，通过构造函数接受被装饰的咖啡对象。
  3. 具体装饰器类 MilkDecorator 和 SugarDecorator：
    • 继承自 CoffeeDecorator，实现了 getDescription 和 cost 函数，以添加额外的功能。
    • MilkDecorator 添加了牛奶，SugarDecorator 添加了糖。
  4. 主函数调用：
    • 创建基础咖啡对象 SimpleCoffee，然后通过装饰器依次添加牛奶和糖。
    • 输出咖啡的描述和成本。
  5. 新增功能的装饰器 TemperatureDecorator 和 FoamDecorator：
    • TemperatureDecorator 添加了温度的装饰，FoamDecorator 添加了奶泡的装饰。
    • 这些装饰器可以动态地为咖啡对象添加新的功能，而不影响原有类的结构。
  6. 新的具体咖啡类 Espresso：
    • Espresso 是一个新的具体咖啡类，实现了 Coffee 接口。
    • 输出描述为 "Espresso"，成本为 2.0。
  7. 主函数调用中新增复杂组合的咖啡：
    • 创建一个复杂的咖啡，包括糖、牛奶、温度装饰、奶泡装饰等。
    • 输出咖啡的描述和成本。
不使用装饰器模式的对比：
  1. 基础咖啡类 SimpleCoffeeSimple：
    • SimpleCoffeeSimple 只是一个简单的咖啡类，没有考虑添加额外功能的可能性。
  2. 每个组合的咖啡类：
    • CoffeeWithMilkSimple、CoffeeWithMilkAndSugarSimple 等都是通过直接继承和组合来实现的。
    • 每个新的组合都需要创建一个新的类，导致类的层次结构不断扩展。
  3. 温度和奶泡的功能：
    • 如果要添加温度或奶泡的功能，可能需要修改每个具体类，导致类的修改。
  4. 可扩展性和灵活性：
    • 不使用装饰器模式，类的层次结构可能变得复杂，且不容易扩展。
    • 添加新的功能可能需要修改现有类，违反了开闭原则。
  5. 代码重复：
    • 针对每个具体咖啡，可能需要重复实现相似的功能，导致代码冗余。

通过比较可以看到，使用装饰器模式的优势在于系统的灵活性和可扩展性。在不使用装饰器模式的情况下，可能会导致类层次结构的不断扩展，代码变得难以维护和扩展。而装饰器模式允许在运行时动态地添加新功能，而无需修改原有类的结构，使得系统更加灵活和易于扩展。

相关推荐
奋斗的小花生3 小时前
c++ 多态性
开发语言·c++
闲晨3 小时前
C++ 继承：代码传承的魔法棒，开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
UestcXiye4 小时前
《TCP/IP网络编程》学习笔记 | Chapter 3：地址族与数据序列
c++·计算机网络·ip·tcp
霁月风5 小时前
设计模式——适配器模式
c++·适配器模式
jrrz08286 小时前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
咖啡里的茶i6 小时前
Vehicle友元Date多态Sedan和Truck
c++
WaaTong6 小时前
《重学Java设计模式》之 单例模式
java·单例模式·设计模式
海绵波波1076 小时前
Webserver(4.9)本地套接字的通信
c++
@小博的博客6 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
爱吃喵的鲤鱼7 小时前
linux进程的状态之环境变量
linux·运维·服务器·开发语言·c++
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除