C++设计模式::装饰模式or代理模式or面向切片编程（AOP）

一个实例

装饰模式：动态地给一个对象（而非一个类）添加一些额外的职责。就增加功能来说，装饰模式比创建子类更加灵活，因为有时我们的需求是给某个对象而不是整个类添加一些功能，比如为一部手机添加增加挂件、屏幕贴膜等等特性，一种比较灵活的方式，将手机（被装饰器类）嵌入到另一个对象（装饰器类）中（两者之间是一种组合关系），有这个对象（装饰器类）完成对象新特性的添加。

如上面的装饰器UML类图所示，装饰器类作为被装饰器类的兄弟类派生自同一个基类，二者接口一致，因此它对该组件的客户透明。图中我们也可以看到，用于装饰的装饰器类可以被独立出来，可单独发展，这无疑能够简化具体被修饰类的设计，使其专注于其核心功能的实现。

class IHello
{
public:
    virtual ~IHello() {}       // 将多态基类的析构函数声明为virtual
    virtual void show() = 0;
                    // 子类只有实现该接口才可进行对象的实例化工作
};

class Hello :public IHello
{
private:
    std::string _name;
public:
    Hello(const std::string& name):_name(name){}
    void show() { std::cout << "hello " + _name << std::endl;}
};

class HelloDecorator :public IHello
{
private:
    IHello* _hello;
    virtual void addDecorator() = 0;
public:
    HelloDecorator(IHello* hello):_hello(hello){}
    void show() { _hello->show();}
};

class HelloDecoratorA :public HelloDecorator
{
private:
    void addDecorator() { std::cout << "logging in ..." << std::endl;}
public:
    HelloDecoratorA(IHello* hello):HelloDecorator(hello){}
    void show()
    {
        addDecorator();
        HelloDecorator::show();
    }
};

class HelloDecoratorB :public HelloDecorator
{
private:
    void addDecorator() { std::cout << "logging out ..." << std::endl;}
public:
    HelloDecoratorB(IHello* hello):_hello(hello){}
    void show() 
    {
        HelloDecorator::show();
        addDecorator();
    }   
};

int main(int, char**)
{
// shard_ptr统一使用基类智能指针，进行堆对象的管理

    std::shared_ptr hello(new Hello("Inside Zhang"));
    std::shared_ptr helloA(new HelloDecoratorA(hello.get()));
    std::shared_ptr helloB(new HelloDecoratorB(hello.get()));
    std::shared_ptr helloAB(new HelloDecoratorB(helloA.get()));
//  helloA->show();
//  helloB->show();
    helloAB->show();
    return 0;
}

这不由得让人联想起装饰器模式与面向切面编程（Aspect Oriented Programming，AOP）的相似性，当我看到一本书中介绍面相切面编程画了一样的UML类图时。面向切面编程是作为面向对象编程的有益补充而被引入的。

1. AOP能够解决一些OOP中的一些问题，或者准确地说，是为了解决继承中存在的问题。

   比如，OOP中的继承是一种纵向的从基类到子类（自上而下）的关系，不适合定义从左到右的横向关系。当继承体系中的许多无关联的对象存在一些公共行为（比如增加打印日志的功能），这些公共行为可能分布在不同的组件不同的对象之中。通过继承方式来提取这些公共行为，这些核心业务逻辑之外的修饰性的功能，就显得力不从心了。

2. AOP提高程序的可维护性。

   AOP将程序的非核心逻辑都“横切”出来，将非核心逻辑和核心逻辑分离，使我们集中精力在核心逻辑上。

可不可以将装饰器模式理解为面向切面编程思想的一种具体的实现方式呢？