如何从装饰物品上去除一层？

Question

How could I remove items that have been added using the decorator design pattern? And such things as remove the lowest/highest costing item or point to it?

Say, for example, I had:

class Beverage
{
private:
    string description;
    double cost;
public:
    virtual string getDescription() { return description; }
    virtual double cost() { return cost };
};

class Espresso : public Beverage
{
public:
    string getDescription()
    {
            return "Espresso";
    }
    double cost()
    {
        return 1.99;
    }
};

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

class Whip : public condimentDecorator
{
private:
    Beverage* beverage;
public:
    Whip(Beverage* beverage)
    {
        this->beverage = beverage;
    }
    double cost()
    {
        return beverage->cost() + 0.20;
    }
};

class Milk : public condimentDecorator
{
private:
    Beverage* beverage;
public:
    Milk(Beverage* beverage)
    {
        this->beverage = beverage;
    }
    string getDescription()
    {
        return beverage->getDescription() + ", Milk";

    }
    double cost()
    {
            return beverage->cost() + 0.10;
    }
};

class Soy : public condimentDecorator
{
private:
    Beverage* beverage;
public:
    Soy(Beverage* beverage)
    {
        this->beverage = beverage;
    }
    string getDescription()
    {
        return beverage->getDescription() + ", Soy";

    }
    double cost()
    {
            return beverage->cost() + 0.15;
    }
};

And I were to do:

Beverage* coffee = new Espresso();
coffee = new Whip(coffee);
coffee = new Milk(coffee);
coffee = new Soy(coffee);

How could I point to whip as the highest costing item and how could I remove it?

How could I locate with highest costing item without knowing which one it is?. How would I even know it has a whip in the first place, for example? Is there a way a checking what extras it has then removing highest costing item?

Answer 1

You would need Beverage to implement a getBaseBeverage() method, returning itself, and condimentDecorators would need to override the method, returning beverage .

Beverage *base = coffee->getBaseBeverage();
if (base != coffee) {
    double cost = coffee->cost() - base->cost();
}

That gets the cost of the last decorator. You could repeat the operation to get the cost of each previous decorator, perhaps in a loop, and record the largest decorator cost.

Removing a decorator would require creating a new decorator chain that skips the item to be removed, linking instead to that item's getBaseBeverage().

None of this is easy, without making large changes to the classes you gave. You could add a function to Beverage that returns the list of decorators. You could add a function to return the incremental cost of each decorator. You could even add a function to remove a particular decorator from the beverage. But then you have gone far beyond a "decorator" type pattern, to something entirely different.