【C++实战㊹】解锁C++装饰器模式：实战与技巧全解析

奔跑吧邓邓子2025-09-28 18:28

目录

  • 一、装饰器模式的概念
    • [1.1 装饰器模式的定义](#1.1 装饰器模式的定义)
    • [1.2 装饰器模式的适用场景](#1.2 装饰器模式的适用场景)
    • [1.3 装饰器模式的结构](#1.3 装饰器模式的结构)
  • 二、装饰器模式的实战应用
    • [2.1 装饰器模式的实现代码](#2.1 装饰器模式的实现代码)
    • [2.2 装饰器模式与继承的区别](#2.2 装饰器模式与继承的区别)
    • [2.3 装饰器模式的嵌套使用](#2.3 装饰器模式的嵌套使用)
  • 三、装饰器模式的实战技巧
    • [3.1 装饰器模式的透明性设计](#3.1 装饰器模式的透明性设计)
    • [3.2 装饰器模式与接口隔离的结合](#3.2 装饰器模式与接口隔离的结合)
    • [3.3 装饰器模式的性能优化](#3.3 装饰器模式的性能优化)
  • 四、实战项目：文本编辑器功能扩展（装饰器版）
    • [4.1 项目需求](#4.1 项目需求)
    • [4.2 装饰器模式实现文本功能扩展](#4.2 装饰器模式实现文本功能扩展)
    • [4.3 多层装饰（如同时加粗 + 斜体）的功能测试](#4.3 多层装饰（如同时加粗 + 斜体）的功能测试)

一、装饰器模式的概念

1.1 装饰器模式的定义

装饰器模式是一种结构型设计模式，它允许在不改变现有对象结构的情况下，动态地给对象添加额外的职责和行为。与继承不同，继承是静态的，在编译时就确定了类的结构和行为，而装饰器模式是动态的，在运行时可以根据需要灵活地为对象添加或移除功能。例如，在一个图形绘制系统中，我们有一个基本的图形对象，如圆形。如果使用继承的方式来添加不同的绘制风格（如红色边框、蓝色填充等），就需要创建大量的子类，这会导致类的数量急剧增加，代码难以维护。而使用装饰器模式，我们可以创建不同的装饰器类，如RedBorderDecorator、BlueFillDecorator，在运行时根据需求将这些装饰器动态地应用到圆形对象上，实现对圆形对象功能的扩展。这种方式使得代码更加灵活，符合开闭原则，即对扩展开放，对修改关闭。

1.2 装饰器模式的适用场景

  1. 游戏开发：在游戏中，角色的属性和技能常常需要动态变化。以一个角色扮演游戏为例，玩家角色一开始可能只有基本的攻击和防御能力。在游戏过程中，玩家获得了一件魔法装备，这件装备可以给角色增加额外的魔法攻击力，或者获得一个增益魔法，能提升角色的移动速度。这里就可以用装饰器模式，将魔法装备和增益魔法视为装饰器，动态地添加到角色对象上，实现角色能力的扩展。
  2. 图形绘制：在绘制图形时，可能需要为图形添加不同的效果。比如绘制一个矩形，有时需要为它添加阴影效果，有时需要添加发光效果。使用装饰器模式，可以创建ShadowDecorator和GlowDecorator等装饰器类，在运行时根据需求将这些装饰器应用到矩形对象上，实现不同的图形效果。
  3. 避免子类爆炸：当一个类有多种功能组合，且使用继承方式会导致大量子类产生时，装饰器模式是一个很好的选择。比如一个咖啡类，有多种配料（牛奶、糖、巧克力等）可以添加，如果使用继承，为了表示不同配料组合的咖啡，就需要创建大量的子类（拿铁咖啡类继承咖啡类并添加牛奶相关属性和方法、摩卡咖啡类继承咖啡类并添加牛奶和巧克力相关属性和方法等），而使用装饰器模式，只需要创建不同的配料装饰器类，在运行时组合这些装饰器来创建不同的咖啡对象，大大减少了类的数量。

1.3 装饰器模式的结构

  1. 抽象组件（Component）：定义一个对象接口，可以给这些对象动态地添加职责。它是具体组件和装饰器的共同接口，保证了装饰器可以像具体组件一样被使用。例如在图形绘制系统中，Shape接口就是抽象组件，它定义了draw方法，所有具体的图形（如圆形、矩形）和装饰器都实现这个接口。
  2. 具体组件（ConcreteComponent）：实现抽象组件接口的类，是可以被装饰的具体对象，它定义了对象的基本行为。在图形绘制系统中，Circle类就是具体组件，它实现了Shape接口，提供了绘制圆形的基本实现。
  3. 抽象装饰器（Decorator）：实现抽象组件接口，同时持有一个抽象组件类型的成员变量（可以是原始对象或其他装饰器），通过组合将功能动态扩展到该对象。它为具体装饰器提供了统一的抽象，定义了装饰的基本行为。例如在图形绘制系统中，ShapeDecorator类就是抽象装饰器，它实现了Shape接口，并持有一个Shape类型的成员变量，在draw方法中，先调用被装饰对象的draw方法，然后可以添加一些通用的装饰逻辑。
  4. 具体装饰器（ConcreteDecorator）：实现抽象装饰器接口，为具体的装饰行为提供实现，通过调用被装饰对象的行为，并在此基础上添加新的功能。在图形绘制系统中，RedBorderDecorator类就是具体装饰器，它继承自ShapeDecorator，在draw方法中，先调用父类的draw方法（即调用被装饰对象的draw方法），然后添加绘制红色边框的功能。

用 UML 图表示如下：

cpp 复制代码 
@startuml
interface Component {
    +operation()
}

class ConcreteComponent implements Component {
    +operation()
}

class Decorator implements Component {
    -component: Component
    +operation()
}

class ConcreteDecoratorA extends Decorator {
    +operation()
    +addedBehaviorA()
}

class ConcreteDecoratorB extends Decorator {
    +operation()
    +addedBehaviorB()
}

Component <|-- ConcreteComponent
Component <|-- Decorator
Decorator <|-- ConcreteDecoratorA
Decorator <|-- ConcreteDecoratorB
Decorator "1" o-- "1" Component
@enduml

在这个 UML 图中，可以清晰地看到抽象组件、具体组件、抽象装饰器和具体装饰器之间的关系。具体组件实现了抽象组件的接口，提供基本功能；抽象装饰器实现抽象组件接口并持有抽象组件的引用，为具体装饰器提供统一的抽象；具体装饰器继承自抽象装饰器，在调用被装饰对象方法的基础上添加新的功能。

二、装饰器模式的实战应用

2.1 装饰器模式的实现代码

下面通过一个简单的图形绘制示例来展示 C++ 中装饰器模式的实现。假设我们有一个基本的图形接口Shape，以及具体的图形类Circle。现在我们要为图形添加不同的装饰，如绘制边框、填充颜色等。

cpp 复制代码 
#include <iostream>
#include <string>

// 抽象组件：图形接口
class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() {}
};

// 具体组件：圆形
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "绘制圆形" << std::endl;
    }
};

// 抽象装饰器：图形装饰器
class ShapeDecorator : public Shape {
protected:
    Shape* decoratedShape;
public:
    ShapeDecorator(Shape* shape) : decoratedShape(shape) {}
    void draw() const override {
        decoratedShape->draw();
    }
    virtual ~ShapeDecorator() {
        delete decoratedShape;
    }
};

// 具体装饰器：红色边框装饰器
class RedBorderDecorator : public ShapeDecorator {
public:
    RedBorderDecorator(Shape* shape) : ShapeDecorator(shape) {}
    void draw() const override {
        ShapeDecorator::draw();
        std::cout << "绘制红色边框" << std::endl;
    }
};

// 具体装饰器：蓝色填充装饰器
class BlueFillDecorator : public ShapeDecorator {
public:
    BlueFillDecorator(Shape* shape) : ShapeDecorator(shape) {}
    void draw() const override {
        ShapeDecorator::draw();
        std::cout << "填充蓝色" << std::endl;
    }
};

在上述代码中，Shape是抽象组件，定义了绘制图形的接口；Circle是具体组件，实现了绘制圆形的功能；ShapeDecorator是抽象装饰器，持有一个Shape指针，并重写了draw方法，在draw方法中调用被装饰对象的draw方法；RedBorderDecorator和BlueFillDecorator是具体装饰器，分别实现了绘制红色边框和填充蓝色的功能。

2.2 装饰器模式与继承的区别

  1. 扩展方式 ：
    • 继承：是一种静态的扩展方式，在编译时就确定了类的结构和行为。子类继承父类的属性和方法，并且可以重写父类的方法来扩展功能。例如，如果我们有一个Animal类，有run方法，Dog类继承自Animal类，Dog类可以重写run方法来实现自己的奔跑方式。但是，如果需要为Dog类添加新的功能，比如bark（叫）功能，就需要在Dog类中添加新的方法，或者创建一个新的子类继承自Dog类并添加bark方法。如果有多种不同类型的动物，每种动物都有不同的功能组合，使用继承会导致子类数量急剧增加，代码难以维护。
    • 装饰器模式：是一种动态的扩展方式，在运行时可以根据需要灵活地为对象添加或移除功能。通过将装饰器对象包装在被装饰对象外面，在保持接口一致的情况下，为对象添加新的行为。比如在上述图形绘制的例子中，我们可以在运行时根据需求决定是否为圆形添加红色边框装饰器或蓝色填充装饰器，而不需要修改Circle类的代码。
  2. 灵活性 ：
    • 继承：灵活性较差，因为一旦子类继承了父类，其功能和行为在编译时就基本确定了。如果需要修改或扩展功能，可能需要修改子类的代码，甚至需要修改父类的代码，这可能会影响到其他子类。
    • 装饰器模式：非常灵活，可以根据不同的需求组合不同的装饰器，为对象添加不同的功能。而且添加新的装饰器不需要修改现有代码，只需要创建新的装饰器类并在运行时进行组合即可，符合开闭原则。
  3. 代码维护性 ：
    • 继承：当子类数量较多时，代码的维护性会变得很差。因为每个子类都可能有自己的特性和行为，修改一个子类可能会影响到其他子类，而且很难跟踪和理解整个继承体系的逻辑。
    • 装饰器模式：代码维护性较好，每个装饰器只负责一种功能的扩展，职责单一，易于理解和维护。如果需要修改或添加功能，只需要修改或添加相应的装饰器类，不会影响到其他部分的代码。

2.3 装饰器模式的嵌套使用

装饰器模式的一个强大之处在于可以进行多层装饰，通过嵌套多个装饰器来为对象添加多种不同的功能。例如，我们可以同时为圆形添加红色边框和蓝色填充的装饰。

cpp 复制代码 
int main() {
    Shape* circle = new Circle();
    circle->draw();

    std::cout << "--- 添加红色边框装饰 ---" << std::endl;
    Shape* redBorderCircle = new RedBorderDecorator(circle);
    redBorderCircle->draw();
    delete redBorderCircle;

    std::cout << "--- 添加蓝色填充装饰 ---" << std::endl;
    Shape* blueFillCircle = new BlueFillDecorator(circle);
    blueFillCircle->draw();
    delete blueFillCircle;

    std::cout << "--- 同时添加红色边框和蓝色填充装饰 ---" << std::endl;
    Shape* redBorderAndBlueFillCircle = new RedBorderDecorator(new BlueFillDecorator(circle));
    redBorderAndBlueFillCircle->draw();
    delete redBorderAndBlueFillCircle;

    delete circle;

    return 0;
}

在main函数中，首先创建一个Circle对象并绘制。然后分别创建添加红色边框装饰的RedBorderDecorator对象、添加蓝色填充装饰的BlueFillDecorator对象，以及同时添加红色边框和蓝色填充装饰的嵌套装饰器对象。通过这种方式，可以看到装饰器模式如何灵活地组合多种功能。

嵌套使用时的注意事项：

  1. 装饰顺序：装饰器的顺序很重要，不同的顺序可能会导致不同的结果。例如，先添加红色边框装饰再添加蓝色填充装饰，和先添加蓝色填充装饰再添加红色边框装饰，绘制的效果可能不同。在实际应用中，需要根据具体的业务需求确定装饰器的顺序。
  2. 内存管理：在使用装饰器模式时，需要注意内存管理。由于装饰器对象持有被装饰对象的指针，在释放装饰器对象时，需要确保被装饰对象也被正确释放，避免内存泄漏。在上述代码中，通过在ShapeDecorator的析构函数中释放decoratedShape来解决内存管理问题。

嵌套使用的优势：

  1. 功能多样性：通过多层装饰，可以为对象添加丰富多样的功能，满足复杂的业务需求。比如在一个游戏开发中，一个角色对象可以通过多层装饰，同时拥有攻击力提升、防御力提升、速度提升等多种功能。
  2. 代码复用性：每个装饰器只负责一种功能的扩展，不同的装饰器可以在不同的场景中复用，提高了代码的复用性。例如，上述的RedBorderDecorator和BlueFillDecorator可以应用到其他类型的图形对象上。

三、装饰器模式的实战技巧

3.1 装饰器模式的透明性设计

在装饰器模式中，透明性设计至关重要，它使得客户端在使用被装饰对象时，无需关心对象是否被装饰以及被装饰的具体情况，就像使用原始对象一样自然。这主要通过保持接口一致性来实现。

  1. 接口一致性：抽象组件定义了统一的接口，具体组件和所有装饰器都实现这个接口。以之前的图形绘制示例来说，Shape接口定义了draw方法，Circle类（具体组件）实现了draw方法来绘制圆形，ShapeDecorator类（抽象装饰器）以及RedBorderDecorator、BlueFillDecorator类（具体装饰器）也都实现了draw方法。这样，客户端代码在调用draw方法时，无论是调用Circle对象的draw方法，还是调用被装饰后的RedBorderDecorator或BlueFillDecorator对象的draw方法，都使用相同的接口形式，无需进行额外的判断和处理。
cpp 复制代码 
Shape* circle = new Circle();
circle->draw(); // 调用具体组件Circle的draw方法

Shape* redBorderCircle = new RedBorderDecorator(circle);
redBorderCircle->draw(); // 调用装饰器RedBorderDecorator的draw方法，客户端无感知装饰
  1. 隐藏装饰细节：装饰器在实现新功能时，应尽量将装饰逻辑隐藏在内部，只对外暴露与抽象组件一致的接口。例如，RedBorderDecorator在draw方法中，先调用被装饰对象的draw方法绘制图形，然后添加绘制红色边框的逻辑，但这些内部实现细节对于客户端来说是不可见的。客户端只看到一个draw方法，调用这个方法就可以得到绘制图形并带有红色边框的结果，而不需要了解具体是如何实现的。
  2. 使用抽象装饰器：抽象装饰器作为具体装饰器的抽象基类，为保持透明性提供了重要的支持。它实现了抽象组件的接口，并持有一个抽象组件类型的成员变量，通过这个成员变量来调用被装饰对象的方法。具体装饰器继承自抽象装饰器，只需要专注于添加新的功能，而不需要关心如何保持接口一致性和与被装饰对象的交互等通用逻辑，这些都由抽象装饰器来处理。例如，ShapeDecorator类实现了Shape接口的draw方法，在draw方法中调用decoratedShape->draw()，将具体的绘制逻辑委托给被装饰对象，而RedBorderDecorator和BlueFillDecorator继承自ShapeDecorator，只需要在draw方法中添加各自的装饰逻辑即可。

3.2 装饰器模式与接口隔离的结合

接口隔离原则强调客户端不应该依赖它不需要的接口，将装饰器模式与接口隔离原则结合，可以避免接口污染，提高代码的可维护性和可扩展性。

  1. 细粒度接口设计：在使用装饰器模式时，为抽象组件设计细粒度的接口，确保每个接口只包含客户端真正需要的方法。以图形绘制系统为例，如果有一些图形可能需要支持旋转操作，而另一些图形不需要，那么可以将旋转操作单独定义在一个接口中，如RotatableShape接口，然后让需要支持旋转的图形类（具体组件）实现这个接口。这样，对于不需要旋转功能的图形，就不会依赖RotatableShape接口，避免了不必要的接口依赖。
cpp 复制代码 
// 定义旋转接口
class RotatableShape {
public:
    virtual void rotate(int degrees) = 0;
    virtual ~RotatableShape() {}
};

// 圆形类实现旋转接口
class Circle : public Shape, public RotatableShape {
public:
    void draw() const override {
        std::cout << "绘制圆形" << std::endl;
    }
    void rotate(int degrees) override {
        std::cout << "圆形旋转 " << degrees << " 度" << std::endl;
    }
};
  1. 装饰器接口与被装饰对象接口一致：确保装饰器实现的接口与被装饰对象的接口一致，这样可以保证客户端在使用装饰器时，不会因为接口不一致而产生额外的依赖。同时，对于不同的装饰器，可以根据其功能定义不同的接口，进一步实现接口隔离。例如，在图形绘制系统中，RedBorderDecorator和BlueFillDecorator都实现了Shape接口，保持了与被装饰对象接口的一致性。如果RedBorderDecorator有一些特定的设置边框宽度、颜色等方法，这些方法可以定义在一个单独的接口中，如BorderDecoratorInterface，RedBorderDecorator实现这个接口，这样就将与边框装饰相关的方法隔离出来，避免污染其他装饰器和被装饰对象的接口。
cpp 复制代码 
// 定义边框装饰器接口
class BorderDecoratorInterface {
public:
    virtual void setBorderWidth(int width) = 0;
    virtual void setBorderColor(const std::string& color) = 0;
    virtual ~BorderDecoratorInterface() {}
};

// 红色边框装饰器实现边框装饰器接口
class RedBorderDecorator : public ShapeDecorator, public BorderDecoratorInterface {
public:
    RedBorderDecorator(Shape* shape) : ShapeDecorator(shape) {}
    void draw() const override {
        ShapeDecorator::draw();
        std::cout << "绘制红色边框" << std::endl;
    }
    void setBorderWidth(int width) override {
        // 设置边框宽度的实现
    }
    void setBorderColor(const std::string& color) override {
        // 设置边框颜色的实现
    }
};
  1. 避免接口膨胀：如果抽象组件的接口包含过多的方法，可能会导致客户端不得不依赖一些不需要的方法，这违反了接口隔离原则。因此，要避免抽象组件接口的膨胀，只在接口中定义核心的、通用的方法。对于一些可选的、特定的功能，可以通过单独的接口或装饰器来实现。例如，在一个文件操作类中，核心的接口可能是open、read、write、close等方法，而对于一些高级功能，如文件加密、压缩等，可以通过装饰器来实现，并定义相应的接口，如EncryptableFileDecorator实现EncryptableFileInterface接口，包含encrypt和decrypt方法，这样就将文件加密功能隔离出来，避免污染文件操作的核心接口。

3.3 装饰器模式的性能优化

虽然装饰器模式提供了灵活的功能扩展方式，但过度使用装饰器可能会带来性能问题，需要进行合理的优化。

  1. 合理控制装饰层数：多层装饰会增加方法调用的开销，因为每次调用都需要经过多个装饰器的转发。例如，在之前的图形绘制示例中，如果有一个圆形对象被多层装饰，如RedBorderDecorator、BlueFillDecorator、ShadowDecorator等，那么在调用draw方法时，会依次经过每个装饰器的draw方法，每个装饰器都要进行一些逻辑处理和方法调用，这会增加执行时间。因此，要根据实际需求合理控制装饰层数，避免不必要的多层装饰。在设计时，可以评估每个装饰器的必要性，只保留真正需要的装饰器。
  2. 避免不必要的装饰：在运行时，根据实际情况判断是否需要添加装饰器，避免对所有对象都进行不必要的装饰。例如，在一个游戏中，只有特定的角色需要某些特殊的能力加成（通过装饰器实现），那么就只对这些特定角色添加相应的装饰器，而不是对所有角色都进行装饰。可以通过条件判断来决定是否创建和应用装饰器。
cpp 复制代码 
Shape* circle = new Circle();
if (needRedBorder) {
    circle = new RedBorderDecorator(circle);
}
if (needBlueFill) {
    circle = new BlueFillDecorator(circle);
}
circle->draw();
  1. 缓存装饰结果：对于一些计算开销较大的装饰逻辑，可以考虑缓存装饰结果。例如，在一个图片处理系统中，对图片进行模糊处理的装饰器，如果每次调用都重新进行模糊计算，会非常耗时。可以在第一次调用时，缓存模糊处理后的结果，后续再次调用时直接返回缓存的结果，提高性能。可以使用哈希表等数据结构来实现缓存。
cpp 复制代码 
class BlurDecorator : public ImageDecorator {
private:
    Image* cachedBlurredImage = nullptr;
public:
    BlurDecorator(Image* image) : ImageDecorator(image) {}
    Image* getImage() const override {
        if (cachedBlurredImage) {
            return cachedBlurredImage;
        }
        Image* originalImage = decoratedImage->getImage();
        // 进行模糊处理
        Image* blurredImage = applyBlur(originalImage);
        cachedBlurredImage = blurredImage;
        return blurredImage;
    }
};
  1. 使用智能指针管理内存：在 C++ 中，使用装饰器模式时要注意内存管理，避免内存泄漏。使用智能指针（如std::unique_ptr、std::shared_ptr）可以自动管理对象的生命周期，减少内存管理的复杂性。例如，在之前的图形绘制示例中，如果使用原始指针，在释放装饰器对象时，需要确保被装饰对象也被正确释放，而使用智能指针则可以简化这个过程。
cpp 复制代码 
std::unique_ptr<Shape> circle = std::make_unique<Circle>();
std::unique_ptr<Shape> redBorderCircle = std::make_unique<RedBorderDecorator>(std::move(circle));

通过以上性能优化策略，可以在使用装饰器模式时，在获得灵活功能扩展的同时，尽量减少对性能的影响，使代码更加高效和健壮。

四、实战项目：文本编辑器功能扩展（装饰器版）

4.1 项目需求

我们要开发一个简单的文本编辑器，具备基础的文本编辑功能，并且能够动态地为文本添加加粗、斜体、下划线等格式。具体需求如下：

  1. 基础文本编辑：能够输入和显示普通文本内容。
  2. 动态添加加粗功能 ：可以将选中的文本或新输入的文本设置为加粗格式，在显示时以特定的方式表示加粗，例如使用<b>标签包裹文本（如果是 HTML 格式显示），或者在文本前后添加特定符号表示加粗（如文本）。
  3. 动态添加斜体功能 ：能将文本设置为斜体格式，同样以特定方式表示，如使用<i>标签（HTML 格式）或文本表示。
  4. 动态添加下划线功能：为文本添加下划线，在显示时使用<u>标签（HTML 格式）或在文本下方添加连续的符号表示。
  5. 功能组合：支持同时为文本添加多种格式，比如同时加粗和斜体，或者同时具备加粗、斜体和下划线。

4.2 装饰器模式实现文本功能扩展

cpp 复制代码 
#include <iostream>
#include <memory>
#include <string>

// 抽象组件：文本接口
class Text {
public:
    virtual ~Text() = default;
    virtual std::string render() const = 0;
};

// 具体组件：实现基本的文本
class PlainText : public Text {
private:
    std::string content;
public:
    explicit PlainText(const std::string& content) : content(content) {}
    std::string render() const override {
        return content;
    }
};

// 抽象装饰器：继承自Text，并包含一个Text对象的指针
class TextDecorator : public Text {
protected:
    std::shared_ptr<Text> text;
public:
    explicit TextDecorator(std::shared_ptr<Text> text) : text(std::move(text)) {}
    std::string render() const override {
        return text->render();
    }
};

// 具体装饰器：为文本添加加粗格式
class BoldText : public TextDecorator {
public:
    explicit BoldText(std::shared_ptr<Text> text) : TextDecorator(std::move(text)) {}
    std::string render() const override {
        return "<b>" + text->render() + "</b>";
    }
};

// 具体装饰器：为文本添加斜体格式
class ItalicText : public TextDecorator {
public:
    explicit ItalicText(std::shared_ptr<Text> text) : TextDecorator(std::move(text)) {}
    std::string render() const override {
        return "<i>" + text->render() + "</i>";
    }
};

// 具体装饰器：为文本添加下划线格式
class UnderlineText : public TextDecorator {
public:
    explicit UnderlineText(std::shared_ptr<Text> text) : TextDecorator(std::move(text)) {}
    std::string render() const override {
        return "<u>" + text->render() + "</u>";
    }
};

在上述代码中：

  1. Text类是抽象组件，定义了render方法，用于渲染文本。
  2. PlainText类是具体组件，实现了基本的文本渲染功能，它的render方法直接返回文本内容。
  3. TextDecorator类是抽象装饰器，继承自Text，持有一个std::shared_ptr<Text>类型的指针text，并实现了默认的render方法，该方法调用被装饰对象的render方法。
  4. BoldText、ItalicText、UnderlineText类是具体装饰器，分别继承自TextDecorator，重写了render方法，在调用被装饰对象render方法的基础上，为文本添加了加粗、斜体、下划线的格式。

4.3 多层装饰（如同时加粗 + 斜体）的功能测试

cpp 复制代码 
int main() {
    // 创建原始文本
    std::shared_ptr<Text> text = std::make_shared<PlainText>("Hello, World!");
    std::cout << "原始文本: " << text->render() << std::endl;

    // 动态添加加粗装饰
    text = std::make_shared<BoldText>(text);
    std::cout << "加粗文本: " << text->render() << std::endl;

    // 动态添加斜体装饰
    text = std::make_shared<ItalicText>(text);
    std::cout << "加粗且斜体文本: " << text->render() << std::endl;

    // 动态添加下划线装饰
    text = std::make_shared<UnderlineText>(text);
    std::cout << "加粗、斜体且下划线文本: " << text->render() << std::endl;

    return 0;
}

测试结果：

cpp 复制代码 
原始文本: Hello, World!
加粗文本: <b>Hello, World!</b>
加粗且斜体文本: <i><b>Hello, World!</b></i>
加粗、斜体且下划线文本: <u><i><b>Hello, World!</b></i></u>

测试中可能出现的问题及解决方案：

  1. 装饰顺序问题：如果装饰顺序不正确，可能导致显示效果不符合预期。例如，先添加下划线装饰再添加加粗装饰，与先添加加粗装饰再添加下划线装饰，在 HTML 格式显示时标签嵌套顺序不同，可能影响样式。在实际应用中，需要根据用户需求确定正确的装饰顺序。
  2. 内存管理问题：在使用智能指针管理对象时，如果指针的生命周期管理不当，可能导致对象提前释放或内存泄漏。确保在创建和使用装饰器对象时，正确管理智能指针的生命周期。在上述代码中，使用std::shared_ptr来管理对象，std::shared_ptr会自动处理对象的引用计数，当引用计数为 0 时，自动释放对象。
  3. 样式冲突问题：某些情况下，不同的装饰器添加的样式可能会产生冲突。例如，同时添加两种不同颜色的字体装饰器，可能导致显示异常。在设计装饰器时，需要考虑如何避免或处理这种样式冲突，比如在装饰器中添加逻辑来判断和处理冲突情况。
相关推荐
休息一下接着来2 小时前
C++ 装饰器模式
c++·设计模式·装饰器模式
bkspiderx2 小时前
C++设计模式之结构型模式：装饰器模式（Decorator）
c++·设计模式·装饰器模式
_OP_CHEN3 小时前
C++：（四）类和对象（中）—— 构造、析构与重载
开发语言·c++·类和对象·构造函数·析构函数·运算符重载·日期类
Madison-No74 小时前
【C++】string类的常见接口的使用
开发语言·c++·算法
一只雄牧慕4 小时前
【C++】哈希表
开发语言·数据结构·c++·散列表
代码村新手4 小时前
C语言-操作符
开发语言·c++
老赵的博客4 小时前
c++ 之多态虚函数表
java·jvm·c++
liu****5 小时前
负载均衡式的在线OJ项目编写(四)
运维·c++·负载均衡·个人开发
@卞5 小时前
第十六届蓝桥杯软件赛C组省赛C++题解（京津冀）
c语言·c++·蓝桥杯
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03UV安装并设置国内源04Spec-Kit 使用指南05阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换0646个Nano-banana 精选提示词，持续更新中07Multisim使用教程详尽版--(2025最新版)08KGG转MP3工具|非KGM文件|解密音频09Burp与其他安全工具联动及代理设置教程10Linux下V2Ray安装配置指南