设计模式：UML类图、策略模式、单例模式、工厂模式、观察者模式

一、UML类图：
类与类之间存在6个关系：
1）依赖：类A用到了类B，不是成员变量中用到，而是在成员函数中用到了

2）关联：类A使用了类B，并且是在成员变量中用到的

3）聚合：和关联类似，也是使用实例化来关联，一个是整体，一个是部分

4）组合：相比聚合具有更强的耦合度。部分没有单独存在的意义，整体负责单独的生命周期。

5）继承：

6）实现：纯虚函数

二、策略模式：

strategy中的算法经常变化。所以将strategy中的算法作为虚函数，在派生类中进行重写。Context中包含了一个strategy对象的指针，可以根据需求将该指针指向ABC类。需要添加算法的时候，只要添加派生类，context和strategy不需要修改。

class Strategy{
	virtual AlgorithmInterface()=0;
};

class A:public Strategy{
	AlgorithmInterface();
};

class B:public Strategy{
	AlgorithmInterface();
};

class C:public Strategy{
	AlgorithmInterface();
};

Class Context{
	Strategy* strategy;//包含了一个Strategy的指针
	void ContextInterface(){
		strategy->AlgorithmInterface();//根据对象类型创建算法
}

三、单例模式： 保证一个类只有一个实例
1）懒汉版本：不到万不得已就不会去实例化类，第一次用到类实例的时候才会去实例化
2）饿汉：饥不择食，在单例类定义的时候就进行实例化

懒汉版本：

class Singleton
{
public:
	static Singleton* m_instance;
	static Singleton* getInstance();//在调用这个函数之前没有实例化对象，所以要写成静态函数
private://将构造函数和析构函数私有化
	static mutex SingletonMutex;//静态函数只能调用静态变量
	Singleton() {};
	~Singleton() {};
};

static Singleton::m_instance = nullptr;
static Singleton* Singleton::getInstance() {
	if (m_instance == nullptr) {//因为lock会造成效率降低，因此在先判断是否被实例化，
		SingletonMutex.lock();
		if (m_instance == nullptr) {
			m_instance = new Singleton();
		}
		SingletonMutex.unlock();
	}
	return m_instance;
}

为什么要判断两次nullptr?
当类没有被实例话的时候，两个进程同时通过了第一个nullptr，一个线程加锁并且实例化，解锁后另一个线程也会实例化。因此要两次判断。

饿汉版本：

class Singleton
{
public:
	static Singleton* m_instance;
	static Singleton* getInstance();
private:
	Singleton() {};
	~Singleton() {};
};
static Singleton::m_instance = new Singleton();//在定义的时候就被实例化，所以是线程安全的
static Singleton* Singleton::getInstance() {
	return m_instance;
}

四、工厂方法模式：
简单工厂模式，工厂类包含了逻辑判断，会根据输入来判断实例化哪一个类，但是如果要添加类的时候，需要需改工厂类，违背了开放—封闭原则。因此工厂方法定义了抽象类用于实例化对象的纯虚函数 ，他的子类来负责实例化

class ISplitter
{
public:
	ISplitter();
	virtual ~ISplitter(); 
	virtual void split() = 0;
};

class PictureISplitter:public ISplitter
{
public:
	PictureISplitter();
	virtual ~PictureISplitter();
	virtual void split() {};
};

class BinaryISplitter:public ISplitter
{
public:
	BinaryISplitter();
	virtual ~BinaryISplitter();
	virtual void split() {};
};

class SplitterFactory
{
public:
	SplitterFactory();
	virtual ~SplitterFactory();
	virtual ISplitter* createSplitter() = 0;
};

class PictureSplitterFactory:public SplitterFactory
{
public:
	PictureSplitterFactory();
	virtual ~SplitterFactory();
	virtual ISplitter* createSplitter{
		return new PictureISplitter();
	}
};

class BinarySplitterFactory :public SplitterFactory
{
public:
	BinarySplitterFactory();
	virtual ~BinarySplitterFactory();
	virtual ISplitter* createSplitter{
		return new BinaryISplitter();
	}
};

五、抽象工厂模式：
之前的工厂模式product只有一个，当product有多个的时候，并且product的派生类之间有依赖关系的时候，则可以用同一个具体工厂同时创建这些对象

六、观察者模式：
定义了一对多的依赖关系，多个观察者对同一个对象进行观察，当被观察对象发生了改变会通知所有的观察者，观察者会根据这个进行相应的措施。