常用设计模式（C++版本）

设计模式

设计模式的概念：
  模式是特定环境下人们解决某类重复出现问题的一套成功或有效的解决方案。
  设计模式是一套被反复使用、多数人知晓的代码设计经验的总结，使用设计模式是为了可重用代码。
  适用场景：序列号生成器、Web页面计数器等

一、单例模式：

  保证一个类仅有一个实例，该实例被所有的程序模块共享。
  该类不能被复制，该类不能被公开创造，构造函数为private，不能被外界实例化，只有一个实例，且为静态变量(static修饰)；还要提供一个静态成员方法，向外界提供当前类实例，只能在类内实例化。

1. 懒汉式单例模式(第一次使用时初始化，单线程安全，多线程不安全)

class singleton{
private:
    singleton();
    static singleton* instance;                 //静态指针保存唯一实例
public:
    static singleton* get_instance(){           //静态成员方法，创建唯一类
        if(instance == NULL)
            instance = new singleton;
        return instance;
    }
};

2. 改进的懒汉式 (创建对象时加锁，线程安全)

class singleton{
private:
    singleton();
    static singleton* instance;
public:
    static singleton* get_instance(){
        lock();
        if(instance == NULL)
            instance = new singleton;
        unlock();
        return instance;
    }
}

3. 饿汉式（懒汉式是通过时间换空间，饿汉式是通过空间换时间，一开始就创建好了对象,线程安全）

class singletio{
private:
    singleton(){}
public:
    static singleton* get_instance(){
        static singleton instance;
        return &instance;
    }
};

二、简单工厂模式：

  简单工厂模式实质是工厂类根据传入的参数动态决定创建哪一类产品的实例。
举个例子：
  有两种单核处理器A和B，只有一个工厂，工厂内部决定生产哪种处理器。

enum CTYPE{COREA, COREB};
class singleCore{
public:
    virtual void show() = 0;
};
//单核A
class singleCoreA : public singleCore{
public:
    void show(){cout << "CoreA";}
}
//单核B
class singleCoreB : public singleCore{
public:
    void show(){cout << "CoreB";} 
}
//唯一的工厂，内部判断生产哪种产品
class factor{
public:
    singleCore* produce_Core(enum CTYPE type){
        if(type == COREA)
            return new singleCoreA;
        if(type == COREB)
            return new singleCoreB;
    }
};

缺点：
  只有一个工厂，工厂类不够灵活，如果新增一个产品就要修改工厂类，违反了开放封闭原则。

三、工厂模式：

  定义一个创建对象的接口，让子类决定实例化哪个类。
  每增加一种产品，就需要增加一个对象的工厂。

class singleCore{
public:
    virtual void show() = 0;
};
//单核A
class singleCoreA : public singleCore{
public:
    void show(){cout << "CoreA";}
}
//单核B
class singleCoreB : public singleCore{
public:
    void show(){cout << "CoreB";} 
}
//工厂类
class factor{
public:
    virtual create_singleCore() = 0;
};
//工厂A
class factorA : public factor{
    singleCoreA* create_singleCore(){
        return new singleCoreA;
    }
};
//工厂B
class factorB: public factor{
    singleCoreB* create_singleCore(){
        return new singleCoreB;
    }
};

四、抽象工厂模式：

//单核
class singleCore{
public:
    virtual void show() = 0;
};
class singleCoreA : public singleCore{
public:
    void show(){cout << "CoreA";}
}
class singleCoreB : public singleCore{
public:
    void show(){cout << "CoreB";} 
}
//多核
class multiCore{
public:
    virtual void show() = 0;
};
class multiCoreA : public multiCore{
public:
    void show(){cout << "multiCoreA";}
}
class multiCoreB : public multiCore{
public:
    void show(){cout << "multiCoreB";} 
}

//工厂A
class factorA : public factor{
    singleCoreA* create_singleCore(){
        return new singleCoreA;
    }
    multiCoreA* create_multiCore(){
        return new multiCoreA;
    }
};
//工厂B
class factorB: public factor{
    singleCoreB* create_singleCore(){
        return new singleCoreB;
    }
    multiCoreB* create_multiCore(){
        return new multiCoreB;
    }
};

特点：
  当添加不同种类产品时。需要修改工厂类，违反开闭原则。

五、装饰器模式：

  继承一个现有类，在子类进行扩展功能，把一个类对象嵌入到另一个类中，进行功能扩展，嵌入的“壳子”即所谓的装饰器。
  允许向一个现有的对象添加额外的功能，同时不改变其结构，是作为现有的类的一个包装，动态的给对象一些额外的功能，装饰器模式比生成子类实现更为灵活。

适用场景：
  （1）在不影响其他对象的情况下，给单个对象动态扩展功能；
  （2）不宜使用继承的方式进行扩展的时候，可以使用装饰器模式。

优点：
  扩展方便，符合开闭原则。

缺点：
  额外增加较多小对象，大量小对象会占用较多系统资源。

实例：
  有一个手机，为手机添加新的功能特性，一种灵活设计方式是将手机嵌入到另一对象中，由这个对象完成特性的添加，嵌入的对象为装饰。

//抽象手机类
class Phone{
public:
    Phone(){}
    virtual ~Phone(){}
    virtual void showDecorate(){}
};

//具体手机类
class iPhone : public Phone{
private:
    string name;
public:
    iPhone(string _name) : name(_name) {}
    ~iPhone() {}
    void showDecorate(){
        cout << name << "的装饰" << endl;
    }
};

class NokiaPhone : public Phone{
private:
    string name;
public:
    NokiaPhone(string _name) : name(_name) {}
    ~NokiaPhone() {}
    void showDecorate(){
        cout << name << "的装饰" << endl;
    }
};

//装饰器抽象类
class DecoratorPhone : public Phone{ 
private:
    Phone* m_Phone;     //要修饰的手机
public:
    DecoratorPhone(Phone* phone) : m_Phone(phone) {}
    virtual void showDecorate(){
        m_Phone->showDecorate();
    }
};

//具体装饰器类
class DecoratorPhoneA : public DecoratorPhone{
public:
    DecoratorPhoneA(Phone* ph) : DecoratorPhone(ph) {}
    void showDecorate(){
        DecoratorPhone::showDecorate();
        AddDecorate();
    }
private:
    void AddDecorate(){
        cout << "增加挂件！" << endl;
    }
};

class DecoratorPhoneB : public DecoratorPhone{
public:
    DecoratorPhoneB(Phone* ph) : DecoratorPhone(ph) {}
    void showDecorate(){
        DecoratorPhone::showDecorate();
        AddDecorate();
    }
private:
    void AddDecorate(){
        cout << "屏幕贴膜！" << endl;
    }
};

六、观察者模式

  观察者模式又称为发布订阅模式，定义了对象间的一对多依赖关系，使得每当一个对象状态发生改变时，其相关的依赖对象皆得到通知并更新，常用于实时事件处理系统、支持广播通信，符合开闭原则。

例子：
  博客订阅的例子，当博主发布新的文章时，即博主的状态发生了改变，订阅的读者就会收到通知，博主与读者之间存在一种一对多的依赖关系。

//观察者
class Observer{
public:
    Observer(){}
    virtual ~Observer(){}
    virtual void Update(){}    
};

//博主
class Blog{
public:
    Blog(){}
    virtual ~Blog(){}
    void Attach(Observer* observer) {        //添加观察者
        m_obsever.push_back(observer);
    }
    void Remove(Observer* observer){         //移除观察者
        m_obsever.remove(observer);
    }
    void Notify(){                           //通知观察者
        list<Observer*> :: iter = m_observer.begin();
        for(; iter != m_observer.end(); ++iter)
            (*iter)->Update();
    }
    virtual void SetStatus(string s){        //设置状态
        m_status = s;
    } 
    virtual string GetStatus(){              //获得状态
        return m_status;
    }
private:
    list<Observer*> m_observers;             //观察者信息链表
protected：
    string m_status;                         //状态
}