C++ 装饰器模式

装饰器模式的特点

首先，装饰器模式是结构型模式，准确来说是对象结构型模式。在不改变该类结构的情况下，给现有对象添加新的功能。总的来说，装饰器模式就是为了给现有对象添加新的功能，而设计模式的原则中的开闭原则是不尽量不改变类的现有结构的。一般为一个现有对象添加新的功能，我们往往能想到的方式有两种：其一，通过继承的方式；其二，通过组合的方式。但这两种方式都更改了该类的结构，实际上，装饰器可以看成这两种方式的结合体。下面分别举例说明这两种方式，最后再介绍装饰器模式。
例子如下：在二维平面有各种形状，比如有矩形、圆，进行画图，代码如下所示：

struct Point
{
    double __x;
    double __y;
    Point(double x, double y):__x(x), __y(y){}
};

class Shape
{
public:
    virtual void show() const = 0;
};

class Circle : public Shape
{
private:
    Point center;
    double radius;
public:
    Circle(Point pnt, double rds):center(pnt), radius(rds){}
    virtual void show() const
    {
        std::cout<<"I draw a Circle: "<<std::endl;
        std::cout<<"center: "<<"("<<center.__x<<","<<center.__y<<")"<<"\t";
        std::cout<<"radius: "<<radius<<std::endl;
    }
};

int main()
{
    Shape* circle = new Circle(Point(3, 4), 1.0);
    circle->show();
    return 0;
}

现在我想添加新的功能，用红色画圆。

1.继承的方式添加新功能

先上代码：

struct Point
{
    double __x;
    double __y;
    Point(double x, double y):__x(x), __y(y){}
};

struct Color
{
    unsigned short __r :8;
    unsigned short __g :8;
    unsigned short __b :8;
    Color(unsigned char r, unsigned char g, unsigned char b):__r(r),__g(g),__b(b){}
};

class Shape
{
public:
    virtual void show() const = 0;
};

class Circle : public Shape
{
private:
    Point center;
    double radius;
public:
    Circle(Point pnt, double rds):center(pnt), radius(rds){}
    virtual void show() const
    {
        std::cout<<"I draw a Circle: "<<std::endl;
        std::cout<<"center: "<<"("<<center.__x<<","<<center.__y<<")"<<"\t";
        std::cout<<"radius: "<<radius<<std::endl;
    }
};

class ColorCircle : public Circle
{
private:
    Color color;
public:
    ColorCircle(Point pnt, double rds, Color clr): Circle(pnt, rds), color(clr){}

    virtual void show() const
    {
        std::cout<<"Use RGB: "<<"("<<color.__r<<","<<color.__g<<","<<color.__b<<")"<<std::endl;
        Circle::show();
    }
};

int main()
{
    Shape* circle = new ColorCircle(Point(3, 4), 1.0, Color(255, 0, 0));
    circle->show();
    return 0;
}

这里用了一个ColorCircle 继承至Circle，这样也解决了新功能，看上去也没有修改原类的结构。而实际上，如果想使用红色画长方形呢？是不是又要用矩形的类继承一个新的类呢？也就是为每一个类添加新的功能，就要多一个类进行实现。这样显然不符合设计模式的原则。

2.使用组合的方式进行实现

代码如下：

struct Point
{
    double __x;
    double __y;
    Point(double x, double y):__x(x), __y(y){}
};

struct Color
{
    unsigned short __r :8;
    unsigned short __g :8;
    unsigned short __b :8;
    Color(unsigned char r, unsigned char g, unsigned char b):__r(r),__g(g),__b(b){}
};

class Shape
{
public:
    virtual void show() const = 0;
};

class Circle : public Shape
{
private:
    Point center;
    double radius;
public:
    Circle(Point pnt, double rds):center(pnt), radius(rds){}
    virtual void show() const
    {
        std::cout<<"I draw a Circle: "<<std::endl;
        std::cout<<"center: "<<"("<<center.__x<<","<<center.__y<<")"<<"\t";
        std::cout<<"radius: "<<radius<<std::endl;
    }
};

class ColorCircle
{
private:
    Circle circle;
    Color color;
public:
    ColorCircle(Point pnt, double rds, Color clr):circle(pnt, rds),color(clr){}
    virtual void show() const
    {
        std::cout<<"Use RGB: "<<"("<<color.__r<<","<<color.__g<<","<<color.__b<<")"<<std::endl;
        circle.show();
    }
};

int main()
{
    ColorCircle* circle = new ColorCircle(Point(3, 4), 1.0, Color(255, 0, 0));
    circle->show();
    return 0;
}

上面通过ColorCircle类组合circle类，实现了用红笔画圆的新功能，但问题依旧是这样，用红笔画矩形呢？是不是有要用新的类组合矩形类？当然，有人会说：我用一个类组合各种形状，对各种形状一一实现新功能，原则上是可行的，但代码没有复用，而且，如果再新增一种形状，是不是又要修改组合的类呢？

装饰器模式实现添加新功能

首先通过上面的例子画出UML图，如图所示：

形状类Circle、Rectangle等继承抽象类Shape，而装饰器类ColorShapeDecorator等继承抽象类ShapeDecorator；而ShapeDecorator类既继承抽象类Shape也将Shape类组合，这样就形成了对象结构型装饰器模式。
通过C++代码实现如下：

struct Point
{
    double __x;
    double __y;
    Point(double x, double y):__x(x), __y(y){}
};

struct Color
{
    unsigned short __r :8;
    unsigned short __g :8;
    unsigned short __b :8;
    Color(unsigned char r, unsigned char g, unsigned char b):__r(r),__g(g),__b(b){}
};

class Shape
{
public:
    virtual void show() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape
{
private:
    Point center;
    double radius;
public:
    Circle(Point pnt, double rds):center(pnt), radius(rds){}
    virtual void show() const
    {
        std::cout<<"I draw a Circle: "<<std::endl;
        std::cout<<"center: "<<"("<<center.__x<<","<<center.__y<<")"<<"\t";
        std::cout<<"radius: "<<radius<<std::endl;
    }
};

class ShapeDecorator : public Shape
{
protected:
    Shape* shape;
public:
    virtual void show() const = 0;
    virtual ~ShapeDecorator() = default;
};

class ColorShapeDecorator : public ShapeDecorator
{
private:
    Color color;
public:
    ColorShapeDecorator(Shape* shp, Color clr):color(clr)
    {
        shape = shp;
    }

    virtual void show() const
    {
        std::cout<<"Use RGB: "<<"("<<color.__r<<","<<color.__g<<","<<color.__b<<")"<<std::endl;
        shape->show();
    }

    virtual ~ColorShapeDecorator()
    {
        delete shape;
    }
};

int main()
{
    Shape* circle = new ColorShapeDecorator(new Circle(Point(3, 4), 1.0), Color(255, 0, 0));

    circle->show();
    return 0;
}

装饰器模式的相关扩展设计

其实装饰器模式的扩展设计，一般有两种情况：其一，就是将上图UML类图的Shape类是具体类即不是抽象类；其二，就是上图的UML类图的ShapeDecorator抽象类变成具体类。设计方式和装饰器模式类似，这里不进行赘述，可以参考该博客。

装饰器的优点有二：

装饰类和被装饰类可以独立发展，不会相互耦合
动态的将责任附加到对象身上。

缺点是：多层装饰比较复杂。