【HeadFirst 设计模式】装饰者模式的C++实现

一、案例背景

Starbuzz是以扩张速度最快而闻名的咖啡连锁店。如果你在街角看到它的店，在对面街上肯定还会看到另一家。因为扩张速度实在太快了，他们准备更新订单系统，以合乎他们的饮料供应要求。他们原先的类设计是这样的……

购买咖啡时，可以要求在其中加入各种调料，例如：蒸奶（Steamed Milk）、豆浆（Soy）、摩卡（Mocha，也就是巧克力风味）或覆盖奶泡。星巴克会根据所加入的调料收取不同的费用。所以订单系统必须考虑到这些调料部分。这是他们的第一个尝试……

很明显，Starbuzz为自己制造了一个维护噩梦：如果牛奶的价格上扬怎么办？新增一种焦糖调料风味时怎么办？

二、案例分析

看到这么多类时你肯定也会被震惊到……那么问题来了，如何进行改进呢？一个直截了当的解决方案是利用实例变量和继承，就可以追踪这些调料。比如我们在基类中加上实例变量，这些布尔值代表是否加上该调料（牛奶，豆浆，摩卡，奶泡……）：

#include <iostream>
#include <string>
using namespace std;

class Beverage
{
private:
    string description {};
    bool   milk {};
    bool   soy {};
    bool   mocha {};
    bool   whip {};

public:
    const string getDiscription()
    {
        return description;
    };
    void setDescription(const string& description)
    {
        this->description = description + "(Add " + (milk ? "Milk " : "") + (soy ? "& Soy " : "") + (mocha ? "& Mocha " : "") + (whip ? "& Whip " : "") + ")";
    }

    virtual const float cost()
    {
        return (milk ? 1 : 0) + (soy ? 2 : 0) + (mocha ? 1 : 0) + (whip ? 1.5 : 0);
    }

    const bool hasMilk() const
    {
        return milk;
    };
    void setMilk(const bool value)
    {
        milk = value;
    };
    const bool hasSoy() const
    {
        return soy;
    };
    void setSoy(const bool value)
    {
        soy = value;
    };
    const bool hasMocha() const
    {
        return mocha;
    };
    void setMocha(const bool value)
    {
        mocha = value;
    };
    const bool hasWhip() const
    {
        return whip;
    };
    void setWhip(const bool value)
    {
        whip = value;
    };
};

class HouseBlend : public Beverage
{
public:
    HouseBlend()
    {
        setMilk(true);
        setSoy(true);
        setDescription("House Blend");
    }
    const float cost() override
    {
        return 5.0 + Beverage::cost();
    }
};

class DarkRoast : public Beverage
{
public:
    DarkRoast()
    {
        setMilk(true);
        setWhip(true);
        setDescription("DarkRoast");
    }
    const float cost() override
    {
        return 8.0 + Beverage::cost();
    }
};

class Decaf : public Beverage
{
public:
    Decaf()
    {
        setMilk(true);
        setWhip(true);
        setSoy(true);
        setDescription("Decaf");
    }
    const float cost() override
    {
        return 10.0 + Beverage::cost();
    }
};

int main()
{
    cout << "我点了一杯" + HouseBlend().getDiscription() << "，花了" << HouseBlend().cost() << "元"<<endl;
    cout << "我点了一杯" + DarkRoast().getDiscription() << "，花了" << DarkRoast().cost() << "元"<<endl;
    cout << "我点了一杯" + Decaf().getDiscription() << "，花了" << Decaf().cost() << "元"<<endl;

    return 0;
}

看起来似乎还行。但是如果将来由于原材料上涨某些调料需要上涨价钱怎么办？如果出现了新的调料呢？如果顾客想要双倍摩卡的咖啡呢？

这些变化都需要我们去直接变更源码。

开放关闭原则：类应该对扩展开放，对修改关闭。

我们的目标是允许类容易扩展，在不修改现有代码的情况下，就可以搭配新的行为。这样的设计具有弹性，可以应对改变，可以接收新的功能来应对改变的需求。

让我们来看看使用装饰者模式是怎么解决问题的：

三、代码分析

这里给出相关案例的C++代码实现：

#include <iostream>
#include <string>
using namespace std;

class Beverage
{
protected:
    string description = "unknown Beverage";

public:
    virtual const string getDescription() const
    {
        return description;
    }
    virtual const double cost() const = 0;
};

class CondimentDecorator : public Beverage
{
public:
    virtual const string getDescription() const = 0;
};

class HouseBlend : public Beverage
{
public:
    HouseBlend()
    {
        description = "HouseBlend";
    }

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

class DarkRoast : public Beverage
{
public:
    DarkRoast()
    {
        description = "DarkRoast";
    }

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

class Decaf : public Beverage
{
public:
    Decaf()
    {
        description = "Decaf";
    }

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

class Milk : public CondimentDecorator
{
public:
    Beverage* beverage {};
    Milk(Beverage* beverage)
    {
        this->beverage = beverage;
    }

    const string getDescription() const override
    {
        return beverage->getDescription() + " & Milk";
    }

    const double cost() const override
    {
        return beverage->cost() + 1.0;
    }
};

class Soy : public CondimentDecorator
{
public:
    Beverage* beverage {};
    Soy(Beverage* beverage)
    {
        this->beverage = beverage;
    }

    const string getDescription() const override
    {
        return beverage->getDescription() + " & Soy";
    }

    const double cost() const override
    {
        return beverage->cost() + 2.0;
    }
};

class Mocha : public CondimentDecorator
{
public:
    Beverage* beverage {};
    Mocha(Beverage* beverage)
    {
        this->beverage = beverage;
    }

    const string getDescription() const override
    {
        return beverage->getDescription() + " & Mocha";
    }

    const double cost() const override
    {
        return beverage->cost() + 2.0;
    }
};

class Whip : public CondimentDecorator
{
public:
    Beverage* beverage {};
    Whip(Beverage* beverage)
    {
        this->beverage = beverage;
    }

    const string getDescription() const override
    {
        return beverage->getDescription() + " & Whip";
    }

    const double cost() const override
    {
        return beverage->cost() + 2.0;
    }
};

int main()
{
    Beverage* houseblend        = new Milk(new Soy(new HouseBlend()));
    Beverage* darkRoast         = new Milk(new Soy(new Whip(new DarkRoast())));
    Beverage* decaf             = new Milk(new Whip(new Decaf()));
    // 双倍摩卡
    Beverage* doubleMochaCoffee = new Milk(new Soy(new Mocha(new Mocha(new HouseBlend()))));

    cout << "我点了一杯" + houseblend->getDescription() << "，花了" << houseblend->cost() << "元" << endl;
    cout << "我点了一杯" + darkRoast->getDescription() << "，花了" << darkRoast->cost() << "元" << endl;
    cout << "我点了一杯" + decaf->getDescription() << "，花了" << decaf->cost() << "元" << endl;
    cout << "我点了一杯" + doubleMochaCoffee->getDescription() << "，花了" << doubleMochaCoffee->cost() << "元" << endl;
    return 0;
}