Decorating Pattern

Decorate pattern is to give objects new responsibilities without making any code change to the underlying classes. The Decorator Pattern attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

Inheritance VS. Composite : When inherit behavior by subclassing, the behavior is set statically at compile time. In addition, all subclasses must inherit the same behavior. If however, choose to extend the object's behavior through composition, then, this will be done dynamically. By dynamically composing objects, add new functionality by writing new code rather than altering existing code. Not to change code can lower the chance of introducing bugs or causing unintended side effects in pre-existing code.

Design Principle: Classes should be open for extension, but closed for modification. 

Design a Coffee shop electronic menu: 

we have HouseBlend, DarkRoast, Espresso, and Decaf coffee, On top of each coffee, customer can add milk and mocha decorator.

If we design our system like this, in the future, whenever we add some new flavour, we will need a subclass.... This is pretty bad design.

Think that if we don't use decorator design patter, our design can will behave like this:

1: why use condimentDecorator?

The scenario to use decorator pattern is that there is already an abstract Beverage class. Traditionally the Decorator Pattern does specify an abstract component to try to avoid altering existing code.

2: when to use Decorator Pattern?

The pattern is used at any time to add new behavior. If we relied on interitance, we will have to go in and change existing code any time we want to add new behaviors. This disobeys the OOD principle.

3: Dynamic vs Static

if we rely on inheritance, then our behavior can only be determined statically at compile time. In other words, we get only behavior the superclass gives us or that we override. With composition, we can mix and match decorators any way we like....at RUMTIME!

#include "../header.h"
using namespace std;

class Beverage {
protected:
  string description = "Unknown Beverage";
public:
  Beverage() {}
  ~Beverage() {}
  virtual string getDescription() {
    return description;
  }
  virtual double getCost() = 0;
  virtual void test() {
    cout << "test" << endl;
  }
};

class HouseBlend : public Beverage {
public:
  HouseBlend() {
    description = "HouseBlend";
  }
  ~HouseBlend() {}
  double getCost() {
    return 0.1;
  }
};

class Mocha : public Beverage {
public:
  Mocha() {description = "Mocha";}
  ~Mocha() {}
  double getCost() {
    return 0.2;
  }
};

class BeverageDecorator : public Beverage {
public:
  virtual string getDescription() = 0;
  virtual double getCost() = 0;
};

class Cream : public BeverageDecorator {
private:
  Beverage* beverage;
public:
  Cream(Beverage* b) {beverage = b;}
  ~Cream() {}
  string getDescription() {
    return "cream, " + beverage->getDescription();
  }
  double getCost() {
    return 0.01 + beverage->getCost();
  }
};

class Soy : public BeverageDecorator {
private:
  Beverage* beverage;
public:
  Soy(Beverage* b) {beverage = b;}
  ~Soy() {}
  string getDescription() {
    return "soy, " + beverage->getDescription();
  }
  double getCost() {
    return 0.02 + beverage->getCost();
  }
};

int main(void) {
  Beverage* beverage = new HouseBlend();
  beverage = new Cream(beverage);
  beverage = new Soy(beverage);
  cout << beverage->getDescription() << endl;
  cout << beverage->getCost() << endl;
  beverage->test();
}