设计模式

常见的七种设计模式

单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式、责任链模式

软件设计七大原则（OOP原则）

开闭原则：对扩展开放，对修改关闭。
里氏替换原则：不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义。
依赖倒置原则：要面向接口编程，不要面向实现编程。
单一职责原则：控制类的粒度大小、将对象解耦、提高其内聚性。
接口隔离原则：要为各个类建立它们需要的专用接口。
迪米特法则：一个类应该保持对其它对象最少的了解，降低耦合度。

合成复用原则：多用组合设计类，少继承

单例模式(Singleton Pattern)

①单例类只有一个实例对象

③单例类对外提供一个访问该单例的全局访问点

④、优点
单例模式可以保证内存里只有一个实例，减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点，可以优化和共享资源的访问。
⑤、缺点
单例模式一般没有接口，扩展困难。
单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则

懒汉模式

延时加载， 由调用者实例，多线程情况下会存在线程安全问题，需要加互斥锁进行防护

#include<iostream>
#include<mutex>
 
using namespace std;
/*单例模式：构造函数私有化，对外提供一个接口*/
 
//线程安全的单例模式
class Lazysingleton {
public:
	
	static Lazysingleton* getinstance()
	{
		if (instance == nullptr)
		{
			i_mutex.lock();
			if (instance == nullptr)
			{
				instance = new Lazysingleton();
			}
			i_mutex.unlock();//解锁
		}
		return instance;
	}
private:
    static Lazysingleton* instance;
	static mutex i_mutex;//锁
	Lazysingleton(){}
    Lazysingleton(const Singleton&) = delete;
    Lazysingleton& operator=(const Lazysingleton&) = delete;
};
Lazysingleton* Lazysingleton::instance=nullptr;
mutex Lazysingleton::i_mutex;//类外初始化
 
 
int main()
{
	Lazysingleton* lhsinglep5 = Lazysingleton::getinstance();
	Lazysingleton* lhsinglep6 = Lazysingleton::getinstance();
 
	cout << lhsinglep5 << endl;
	cout << lhsinglep6 << endl;
	return 0;
}

饿汉模式

#include<iostream>
 
using namespace std;
/*单例模式：构造函数私有化，对外提供一个接口*/
 
//饿汉模式：不管用不用得到，都构造出来。本身就是线程安全的
class hungrysingleton {
public:
	static hungrysingleton* getinstance()
	{
		return instance;
	}
 
private:
    static hungrysingleton* instance;
	hungrysingleton() {}
    hungrysingleton(const hungrysingleton&) = delete;
    hungrysingleton& operator=(const hungrysingleton&) = delete;
};
hungrysingleton* hungrysingleton::instance = new hungrysingleton();
 
int main()
{
	hungrysingleton* ehsinglep3 = hungrysingleton::getinstance();
	hungrysingleton* ehsinglep4 = hungrysingleton::getinstance();
 
	cout << ehsinglep3 << endl;
	cout << ehsinglep4 << endl;
 
	return 0;
}