设计模式-单例模式、观察者模式、工厂模式、代理模式、装饰器模式、适配器模式

首先单例模式：
单例模式的实例化
饿汉模式：在类加载的时候就已经初始化完成，不需要考虑线程安全问题

#pragma once 
#include <iostream>
using namespace std;
class Singleton{
private:
    Singleton(){
        cout << "创建了一个单例对象" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //析构函数我们也需要声明成private的
        //因为我们想要这个实例在程序运行的整个过程中都存在
        //所以我们不允许实例自己主动调用析构函数释放对象
        cout << "销毁了一个单例对象" << endl;
    } 
    static Singleton instance;  //这是我们的单例对象，注意这是一个类对象，下面会更改这个类型
public:
    static Singleton* getInstance();
};
 //下面这个静态成员变量在类加载的时候就已经初始化好了
Singleton Singleton::instance; 
 
Singleton* Singleton::getInstance(){
    return &instance;
}

#pragma once
 
#include <iostream>
using namespace std;
 
class Singleton{
private:
    Singleton(){
        cout << "创建了一个单例对象" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //析构函数我们也需要声明成private的
        //因为我们想要这个实例在程序运行的整个过程中都存在
        //所以我们不允许实例自己主动调用析构函数释放对象
        cout << "销毁了一个单例对象" << endl;
    }
    static Singleton* instance;  //这是我们的单例对象,它是一个类对象的指针
public:
    static Singleton* getInstance();
};
 
//下面这个静态成员变量在类加载的时候就已经初始化好了
Singleton* Singleton::instance = new Singleton(); 
 
Singleton* Singleton::getInstance(){
    return instance;    //这里就是直接返回instance了而不是返回&instance
}

#pragma once
 
#include <iostream>
#include <memory>
using namespace std;
 
class Singleton{
private:
    Singleton(){
        cout << "创建了一个单例对象" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //析构函数我们也需要声明成private的
        //因为我们想要这个实例在程序运行的整个过程中都存在
        //所以我们不允许实例自己主动调用析构函数释放对象
        cout << "销毁了一个单例对象" << endl;
    }
    static void DestroyInstance(Singleton*);    //自定义一个释放实例的函数
 
    static shared_ptr<Singleton> instance;  //这是我们的单例对象,它是一个类对象的指针
public:
    static shared_ptr<Singleton> getInstance();
};
  //下面这个静态成员变量在类加载的时候就已经初始化好了
shared_ptr<Singleton> Singleton::instance(new Singleton(),Singleton::DestroyInstance); 
 
shared_ptr<Singleton> Singleton::getInstance(){
    return instance;    
}
void Singleton::DestroyInstance(Singleton*){
    cout << "在自定义函数中释放实例" << endl;
}

懒汉模式：

class Singleton
{
public:
    static Singleton* getIntance() 
    {
        if (pobject == NULL)//懒加载，只有在使用时才生成
        {
            pobject = new Singleton();
        }
        return pobject;
    }
private:
    Singleton(){}
    static Singleton *pobject;
};

class Singleton
{
public:
    static Singleton* getIntance() 
    {
        pthread_mutex_lock(&mutex);//多线程线程安全问题
        if (pobject == NULL)//懒加载，只有在使用时才生成
        {
            pobject = new Singleton();
        }
        pthread_mutex_lock(&mutex);
        return pobject;
    }
private:
    Singleton(){}
    static Singleton *pobject;
};
Singleton* Singleton::pobject = NULL;//快加载 懒加载

class Singleton
{
public:
    static Singleton* getIntance() 
    {
        if (pobject == NULL)//懒加载，只有在使用时才生成
        {
            pthread_mutex_lock(&mutex);//多线程线程安全问题
            if (pobject == NULL)//单线程时效率问题
            {
                pobject = new Singleton();
            }
            pthread_mutex_lock(&mutex);
        }
        return pobject;
    }
private:
    Singleton(){}
    static Singleton *pobject;
};
Singleton* Singleton::pobject = NULL;//快加载 懒加载

class Singleton
{
public:
    volatile static Singleton* getIntance() 
    {
        if (pobject == NULL)//懒加载，只有在使用时才生成
        {
            pthread_mutex_lock(&mutex);//多线程线程安全问题
            if (pobject == NULL)//单线程时的效率问题
            {
                Singleton* temp = new Singleton;
                barrier();//防止CPU对指令进行动态换序优，使对象的构造一定在barrier完成，因此赋值给pobject的对象是完好的
                pobject = temp;
            }
            pthread_mutex_lock(&mutex);
        }
        return pobject;
    }
private:
    Singleton(){}
    volatile static Singleton *pobject;
};
volatile Singleton* Singleton::pobject = NULL;//快加载 懒加载

工厂模式（创建型模型） 工厂模式是为了封装对象的创建。

    为什么使用工厂模式：

1为了提高内聚与低耦合，我们可能有n多个子类继承与基类，每次用到子类都要new之类的，客户必须知道子类的名称，记住命名太过复杂；程序的扩展性和维护变得困难
2还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思
为：假设我们在类 A 中要使用到类 B，B 是一个抽象父类，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句，因为根本就不知道×××是什么。

 Factory 模式的两个重要的功能： 

1）定义创建对象的接口，封装了对象的创建；
2）使得具体化类的工作延迟到了子类中
工厂可以分为简单工厂、工厂方法、抽象工厂；严格上简单工厂是不属于设计模式的。
简单工厂：

工厂方法：

抽象工厂：要创建一组相关或者相互依赖的对象。

**代理模式（结构型模型）：**代理模式类似于权限的控制，委托类拥有很多的功能，代理类中对方法的使用根据不同的代理提供不同的使用权限。委托类就像是公司老总，代理是秘书，代理根据不同的客户选择是否推荐给老大。


代理类使用委托类的某些同名方法，某些不允许使用
装饰器模式： 增加对现有类的功能
虽然可以使用通过子类的方法，来增加现有类的功能，但是代码中要有太多的子类代码添加进去，需要实现。


装饰器是在需要改写的同名方法中，不仅使用需要改写的类的该方法，还添加了一些其他的处理，需要添加的功能。

**适配器模式：**让不兼容的借口可以在一起工作。


在我的成员方法中，去调用某些你的（另一个类）的成员方法。不需要改动源代码，满足封闭原则。
观察者模式：（观察-监听模式、发布订阅模式）（行为型模式：主要关注对象间的通讯）
主要关注的是对象的一对多关系，也就是多个对象都依赖一个对象，当该对象的状态发生改变时，其他对象都能收到相应的通知。