设计模式装饰者模式(c++)

    想象一下有如下的场景：

    有两种主咖啡， 可以搭配任意的饮料，我们的目标是允许类容易扩展，在不修改现有代码的情况下，可以搭配新的行为。这里可以用装饰者模式来实现。

1. uml 图

    装饰者模式动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

    这里吹一下装饰者模式的好处：

• 每个组件都可以单独使用，或者被装饰者包装起来使用
• 装饰者可以扩展组件的状态
• 装饰可以加上新的方法
• 可以为组件添加新的方法而用修改装饰者，反之亦可

2. 代码示例

    首先构造基类

class Beverage 
{ 
 public: 
        virtual int cost() = 0; 
};

    然后 定义组件， 这里定义了两个 Blend 和 DarkRoast

class Blend : public Beverage 
{ 
 public: 
    int cost() 
    { 
        return 1; 
    } 
};

class DarkRoast : public Beverage 
{ 
 public: 
    int cost() 
    { 
        return 2; 
    } 
};

    下一步就定义 装饰者， 这里定义了3个， 所有的装饰者都是从Decorator 类继承的

class Decorator : public Beverage 
{ 
 public: 
    int cost() 
    { 
        return observed_->cost() + 0; 
    } 
    void setObserver(shared_ptr<Beverage> observed) 
    { 
        observed_ = observed; 
    }

 protected: 
    shared_ptr<Beverage> getObserver() 
    { 
        return observed_; 
    }

 private: 
    shared_ptr<Beverage> observed_; 
};

 class Milk : public Decorator 
{ 
 public: 
    int cost() 
    { 
        return getObserver()->cost() + 1; 
    } 
};

 class Mocha : public Decorator 
{ 
 public: 
    int cost() 
    { 
        return getObserver()->cost() + 2; 
    } 
}; 
class Soy : public Decorator 
{ 
public: 
    int cost() 
    { 
        return getObserver()->cost() + 3; 
    } 
};

    最后看下测试代码

int _tmain(int argc, _TCHAR* argv[]) 
{

    shared_ptr<Beverage> blendObserved(new Blend()) ; 
    shared_ptr<Beverage> darkObserved(new DarkRoast());

    shared_ptr<Decorator> blendWithMilk(new Milk()); 
    blendWithMilk->setObserver(blendObserved);

    shared_ptr<Decorator> blendWithMocha(new Mocha()); 
    blendWithMocha->setObserver(blendObserved);

    shared_ptr<Decorator> blendWithSoy(new Soy()); 
    blendWithSoy->setObserver(blendObserved);

    cout<<blendWithMilk->cost()<<endl; 
    cout<<blendWithMocha->cost()<<endl; 
    cout<<blendWithSoy->cost()<<endl; 
    return 0; 
}

3. 总结

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

• 继承属于扩展形式之一，但不见得是达到弹性设计的最佳方式
• 在我们的设计中，应该允许行为可以被扩展，而无需修改实现
• 除了继承，装饰者模式也可以让我们扩展行为，而装饰者模式意味着一群装饰者类来包装具体的组件。
• 装饰者会导致设计中出现许多小对象，如果过度使用会是程序变得复杂。