结构型设计模式

关注类和对象的组合

代理模式

特点:代理控制对对的访问
优点:可以扩展目标对象的功能,使客户端和模板对象分离
缺点:增加一个代理对象请求速度变慢
实现

class AbstractSubject
{
    public:
        virtual void request() = 0;
};
class RealSubject:public AbstractSubject
{
    public:
        void request(){}
};
class Proxy: public AbstractSubject
{
    private:
        RealSubject *rsubject;
    public:
        Proxy(){
            rsubject = new RealSubject();
        }
        void request()
        {
            rsubject->request();
        }
};

适配器模式

特点:将一个类的接口转换成客户希望的另外一个接口
优点:复用现存的类,截距目标类和适配类接口不一致的问题
缺点:业务复杂性强,降低代码可读性
实现

class Target
{
public:
    virtual void request() = 0;
};

class Adaptee
{
public:
    void specialRequest() {}
};

class Adapter : public Target, private Adaptee
{
public:
    void request()
    {
        specialRequest();
    }
};
class ObjectAdapter : public Target
{
private:
    Adaptee *_adaptee;

public:
    ObjectAdapter(Adaptee *adaptee) : _adaptee(adaptee) {}
    void request()
    {
        _adaptee->specialRequest();
    }
};

桥接模式

特点:将抽象与实现分离，使它们可以独立变化
优点:抽象与实现分离，扩展能力强,符合开闭原则,符合合成复用原则
缺点:要求开发者针对抽象化进行设计与编程
实现

class Implementor
{
    public:
        virtual void action() = 0;
};

class ConcreteImplementorA : public Implementor
{
    public:
        void action(){}
};

class Abstraction
{
    public:
        virtual void operation() = 0;
};

class ConcreteAbstraction : public Abstraction
{
    private:
        Implementor *_impl;
    public:
        ConcreteAbstraction(Implementor *impl) : _impl(impl){}
        void operation()
        {
            _impl->action();
        }
};

装饰器模式

特点:指在不改变现有对象结构的情况下，动态地给该对象增加一些职责
优点:比继承灵活,完全遵守开闭原则
缺点:增加许多子类
实现

class Component
{
    public:
        virtual void operation()=0;
};
class ConcreteComponent : public Component
{
    public:
        void operation(){}
};
class Decorator: public Component
{
    private:
        Component *_component;
    public:
        Decorator(Component *c) : _component(c){}
        void operation(){_component->operation();}
};
class ConcreteDecoratorA: public Decorator
{
    public:
        ConcreteDecoratorA(Component *c) : Decorator(c){}
        void operation()
        {
            Decorator::operation();
        }
};

外观模式

特点:为多个复杂的子系统提供一个一致的接口
优点:“迪米特法则”的典型应用
缺点:违背了"开闭原则",能很好地限制客户使用子系统类
实现

class SubSystemA
{
    public:
        void operation(){}
};
class Facade
{
    private:    
        SubSystemA* sysA;
    public:
        Facade():sysA(){}
        void operationA(){sysA->operation();}
};

享元模式

特点:有效地支持大量细粒度对象的复用
优点:相同对象只要保存一份，这降低了系统中对象的数量(减少内存使用)
缺点:对象共享,增加程序复杂性
实现

class Flyweight
{
    private:
        int state;
    public:
        virtual void operation() = 0;
};
class UnsharedConcreteFlyweight: Flyweight
{
    private:
        int state;
    public:
        UnsharedConcreteFlyweight(const int intrinsic_state):
            state(intrinsic_state){}
        void operation(){}
};

class ConcreteFlyweight : public Flyweight
{
    private:
        int state;
    public:
        ConcreteFlyweight(const int all_state):state(all_state){}
        void operation(){}
};
class FlyweightFactory
{
    private:
        std::map<int,Flyweight*> flies;
    public:
        Flyweight *getFlyweight(const int key)
        {
            return new ConcreteFlyweight(key);
        }
};

组合模式

特点:呈树结构
优点:满足“开闭原则”,简化了客户端代码
缺点:设计较复杂,不容易用继承的方法来增加构件的新功能
实现

class Component
{
    public:
        virtual Component *getChild(int){return 0;}
        virtual void add(Component *){}
        virtual void remove(int){}
        virtual void operation() = 0;
};
class Composite: public Component
{
    private:
        std::vector<Component*> children;
    public:
        Component *getChild(const unsigned int index){return children[index];}
        void add(Component *component){}
        void remove(int index){}
        void operation(){}
};
class Leaf:public Component
{
    private:
        int id;
    public:
        Leaf(int i) : id(id){}
        void operation(){}
};