设计模式及其实现

设计模式是针对软件设计过程中面临的一般问题，所提出的可重用的解决方案。
其主要优点有：
1、降低系统的复杂性，使系统更加清晰和易于理解。
2、降低系统的维护成本，使系统更容易对变化进行响应。
3、代码重用，避免重复造轮子。
4、使界面独立于实现，提高系统的扩张性。

以下是一些常见的设计模式：
一、创建型模式：
1、工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

class Product {/*...*/};  
class ConcreteProduct1 : public Product {/*...*/};  
class ConcreteProduct2 : public Product {/*...*/};  

class Factory 
{
public: 
    virtual Product* CreateProduct() = 0;
};

class ConcreteFactory1 : public Factory 
{
public:
    Product* CreateProduct() {return new ConcreteProduct1();}
};

class ConcreteFactory2 : public Factory 
{
public:
    Product* CreateProduct() {return new ConcreteProduct2();}  
}; 

2、抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，则无需指定它们具体的类。

class AbstractProductA {/*...*/};  
class AbstractProductB {/*...*/};

class ConcreteProductA1 : public AbstractProductA {/*...*/};  
class ConcreteProductA2 : public AbstractProductA {/*...*/};    
class ConcreteProductB1 : public AbstractProductB {/*...*/};  
class ConcreteProductB2 : public AbstractProductB {/*...*/};

class AbstractFactory  {  
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;  
};

class ConcreteFactory1 : public AbstractFactory {  
public:
    AbstractProductA* CreateProductA() {return new ConcreteProductA1();}
    AbstractProductB* CreateProductB()  {return new ConcreteProductB1();}  
};

3、单例模式：确保一个类只有一个对象存在。

class Singleton 
{
private:
    static Singleton* instance_;
    Singleton() {}  

public:
    static Singleton* GetInstance();
};

Singleton* Singleton::GetInstance()  
{  
    if (instance_ == 0) {
        instance_ = new Singleton();
    }
    return instance_;
}

4、建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

class Builder  {  
public:
    virtual void ProducePartA() = 0;
    virtual void ProducePartB() = 0;
    virtual void ProducePartC() = 0;
    virtual Product GetResult() = 0;
};

class ConcreteBuilder : public Builder  {
private:
    Product* product;  
public:
    ConcreteBuilder() { product = new Product(); }
    void ProducePartA() {/*...*/} 
    void ProducePartB() {/*...*/}
    void ProducePartC() {/*...*/}
    Product GetResult() { return *product; }
}; 

class Product {/*...*/};

class Director  
{  
private:
    Builder* builder;
public:
   Director(Builder* builder) {this->builder = builder;}
   void Construct() {
       builder->ProducePartA();
       builder->ProducePartB(); 
       builder->ProducePartC();
   }  
};

二、结构性模式
1、适配器模式：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

class Target {/*...*/};
class Adaptee  {/*...*/};
class Adapter : public Target {
private:
    Adaptee* adaptee_;
public:
    Adapter(Adaptee* adaptee) {adaptee_ = adaptee;}
    void Request() {/*...*/}
};

2、桥接模式：将抽象与实现解耦，使两者可以独立地变化

class Abstraction 
{
protected:
    Implementor* implementor_;
public:
    Abstraction(Implementor* implementor) {
        implementor_ = implementor; 
    }
    virtual void Operation() {/*...*/}
};

class RefinedAbstraction : public Abstraction {/*...*/}; 

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

class ConcreteImplementorA : public Implementor {/*...*/};
class ConcreteImplementorB : public Implementor {/*...*/}; 

3、装饰器模式：动态地给一个对象添加一些额外的职责。就功能而言，装饰器模式相当于对原有对象进行包装

class Component {/*...*/};  
class ConcreteComponent : public Component {/*...*/};

class Decorator : public Component  
{
protected:
    Component* component_;
public:
    Decorator(Component* component) {component_ = component;}
    void Operation() {/*...*/} 
};

class ConcreteDecoratorA : public Decorator {/*...*/};
class ConcreteDecoratorB : public Decorator {/*...*/};

4、外观模式：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更容易使用

class SubSystem1 {/*...*/}; 
class SubSystem2 {/*...*/};
class SubSystem3 {/*...*/};

class Facade 
{
protected:
    SubSystem1* subsystem1_;
    SubSystem2* subsystem2_;
    SubSystem3* subsystem3_;
public:
    Facade() {
        subsystem1_ = new SubSystem1();
        subsystem2_ = new SubSystem2();
        subsystem3_ = new SubSystem3();
    } 
    void Operation() {/*...*/}
};

5、享元模式：运用共享技术有效地支持大量细粒度的对象

class Flyweight 
{
private:
    string intrinsicState_;  
public:
    Flyweight(string state) {intrinsicState_ = state;}
    virtual void Operation(string state) = 0; 
    string GetIntrinsicState() {return intrinsicState_;}
};

class ConcreteFlyweight : public Flyweight 
{ 
public:
    ConcreteFlyweight(string state) : Flyweight(state) {}
    void Operation(string state){/*...*/}
};

class FlyweightFactory 
{
private:
    map<string, Flyweight*> pool_;  
public: 
    Flyweight* GetFlyweight(string state) {/*...*/}
}; 

6、代理模式：通过引入一个代理对象来控制对其他对象的访问

class Subject {
public:
    virtual void Request() = 0;  
};

class RealSubject : public Subject {
public:
    void Request() {/*...*/}
};

class Proxy : public Subject  {
private:
    RealSubject* realSubject_;
public:
    Proxy() {realSubject_ = new RealSubject();} 
    void Request() {/*...*/} 
    void DoSomething() {/*...*/} 
};

7、组合模式：通过树形结构来组合对象,实现了对单个对象和组合对象的相同处理。
组合模式创建了对象的树形结构, used 当你想表示部分与整体层次关系的时候。它使得客户端可以忽略对象的具体类型,统一对待树叶和树枝对象。

class Component { 
public:
    virtual void Add(Component* component) {}
    virtual void Remove(Component* component) {}
    virtual string Operation() = 0; 
};

class Leaf : public Component { 
public: 
    string Operation() {/*...*/}
};

class Composite : public Component {  
private:
    list<Component*> children_; 
public:   
    void Add(Component* component) {children_.push_back(component);}
    void Remove(Component* component) {children_.remove(component);}
    string Operation() {/*...*/} 
};

int main() {
    Component* c1 = new Leaf();
    Component* c2 = new Leaf();
    Composite* c3 = new Composite();
    c3->Add(c1);
    c3->Add(c2);
    c3->Operation();
}

三、行为型模式
1、模板方法模式：定义一个算法的骨架，将一些步骤的实现延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

class AbstractClass  {
public:
    void TemplateMethod() {
        PrimitiveOperation1();
        PrimitiveOperation2();
    }
    virtual void PrimitiveOperation1() = 0;
    virtual void PrimitiveOperation2() = 0;
};

class ConcreteClass : public AbstractClass {
public:
    void PrimitiveOperation1() {/*...*/} 
    void PrimitiveOperation2() {/*...*/}
};

2、策略模式：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。

class Strategy {  
public:
    virtual void Algorithm() = 0; 
};

class ConcreteStrategyA : public Strategy {
public:
    void Algorithm() {/*...*/}
};

class ConcreteStrategyB : public Strategy {  
public:
    void Algorithm() {/*...*/}
};

class Context {  
private:
    Strategy* strategy_;
public:
    Context(Strategy* strategy) {
        strategy_ = strategy;
    }
    void DoSomething() {
        strategy_->Algorithm();
    }
};

int main() {
    Context* context;
    context = new Context(new ConcreteStrategyA());
    context->DoSomething();  
    delete context;
    
    context = new Context(new ConcreteStrategyB()); 
    context->DoSomething();
    delete context;
}

3、观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

class Subject {  
private:
    list<Observer*> observers_; 
public:
    void Attach(Observer* observer) {
        observers_.push_back(observer);
    }
    void Detach(Observer* observer) { 
        observers_.remove(observer);
    }
    void Notify() {
        for (Observer* observer : observers_) {
            observer->Update();
        }
    }
};

class Observer {  
public:
    virtual void Update() = 0;
};

class ConcreteObserver : public Observer {
public:
    void Update() { /*...*/ } 
};

int main() {
    Subject* subject = new Subject();
    Observer* obs1 = new ConcreteObserver();
    Observer* obs2 = new ConcreteObserver();
    subject->Attach(obs1);
    subject->Attach(obs2);
    subject->Notify();
} 

4、迭代器模式：提供一种方法访问一个容器对象中的各个元素，而又不需要暴露该对象的内部细节。

template <typename Item>
class Iterator {
public:
    virtual bool HasNext() const = 0;
    virtual Item Next() = 0;
    virtual ~Iterator() {}
};

template <typename Item>
class ConcreteIterator : public Iterator<Item> {
private:
    Item* items_;
    int current_;
public:
    ConcreteIterator(Item* items) {
        items_ = items;
        current_ = 0;
    }
    bool HasNext() {return current_ < Count;}
    Item Next() {return items_[current_++];} 
}; 

5、责任链模式：每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，它会把相同的请求传给下一个接收者。

class Handler {/*...*/};  

class ConcreteHandler1 : public Handler {
private:
    Handler* successor_;
public: 
    virtual bool HandleRequest(string request) {/*...*/}
    void SetSuccessor(Handler* successor) {successor_ = successor;}
};

class ConcreteHandler2 : public Handler {/*...*/};
class ConcreteHandler3 : public Handler {/*...*/};