Day3 STL配置器 单例模式 工厂模式 适配器模式

STL配置器

• 配置器会首先判断区块的大小，大于128bytes就交给一级配置器，若是小于，则调用二级配置器

一级配置器

二级配置器

• 当整个heap无法给内存池分配空间时，则从已经在内存池之中分配好的链表节点找找“尚有未用区块，且区块够大“的free lists，找到就挖出一块，找不到就调用一级配置器。一级配置器其实也是使用malloc()来配置内存，但是其有out-of-memory处理机制

设计模式

单例模式

• 保证一个类只有一个实例，并提供一个访问他的全局访问节点
• 多线程单例，若没有锁的控制，则可能会造成创建多个实例

饿汉式

懒汉式

面临线程访问的安全性问题，需要做双重锁定处理保证安全

三大条件

• 私有化构造器
• 静态的私有对象
• 提供静态的方法去创建或者获取私有对象的值

单例模式实现

//懒汉式 双重验证
class SingletonLazy1 {
public:
	static SingletonLazy1* GetInstance() {
		if (m_instance == nullptr) {	
			std::lock_guard<std::mutex> lock(m_mutex);
			if (m_instance == nullptr) {
				m_instance = new SingletonLazy1;
			}
			
		}
	}
private:
	SingletonLazy1() {}
	~SingletonLazy1() {}
	static std::mutex m_mutex;
	static SingletonLazy1* m_instance;
};

SingletonLazy1* SingletonLazy1::m_instance = nullptr;

//懒汉式 C++11
class SingletonLazy2 {
public:
	//C++11规定了local static在多线程条件下的初始化行为，要求编译器保证了内部静态变量的线程安全性
	static SingletonLazy2* GetInstance() {
		static SingletonLazy2 instance;
		return &instance;
	}
private:
	SingletonLazy2() {}
	~SingletonLazy2() {}
};

//饿汉式
class SingletonEager {
public:
	static SingletonEager* GetInstance() {
		return m_instance;
	}
private:
	SingletonEager() {}
	~SingletonEager() {}
	static SingletonEager * m_instance;
};
SingletonEager* SingletonEager::m_instance = new SingletonEager;

工厂模式

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式

简单工厂实例

//产品抽象类
class Shoes {
public:
	virtual ~Shoes(){}
	virtual void shoesProduction() = 0;
};

//具体的产品
class NikeShoes :public Shoes {
public:
	virtual void shoesProduction() override
	{
		std::cout << "Nike : just do it!" << std::endl;
	}
};

class AdidasShoes :public Shoes {
public:
	virtual void shoesProduction() override
	{
		std::cout << "Adidas : impossible is nothing!" << std::endl;
	}
};

//工厂类
enum ShoesCategory
{
	Nike,
	Adidas
};
class ShoesFactory {
public:
	std::shared_ptr<Shoes> createShoes(ShoesCategory type)
	{
		std::shared_ptr<Shoes> shoe(nullptr);
		switch (type)
		{
		case Nike:
			shoe.reset(new NikeShoes());
			break;
		case Adidas:
			shoe.reset(new AdidasShoes());
			break;
		default:
			break;
		}
		return shoe;
	}
};

工厂方法模式

工厂方法实例

//产品抽象类
class Shoes {
public:
	virtual ~Shoes() {}
	virtual void shoesProduction() = 0;
};

//具体的产品
class NikeShoes :public Shoes {
public:
	virtual void shoesProduction() override
	{
		std::cout << "Nike : just do it!" << std::endl;
	}
};

class AdidasShoes :public Shoes {
public:
	virtual void shoesProduction() override
	{
		std::cout << "Adidas : impossible is nothing!" << std::endl;
	}
};

//工厂抽象类
class ShoesFactory {
public:
	virtual ~ShoesFactory() {}
	virtual std::shared_ptr<Shoes> createShoes() = 0;
};

//具体的产品生产线
class NikeFactory :public ShoesFactory {
public:
	virtual std::shared_ptr<Shoes> createShoes() override
	{
		std::cout << "Nike Factory" << std::endl;
		return std::shared_ptr<Shoes>(new NikeShoes());
	}
};

class AdidasFactory :public ShoesFactory {
public:
	virtual std::shared_ptr<Shoes> createShoes() override
	{
		std::cout << "Adidas Factory" << std::endl;
		return std::shared_ptr<Shoes>(new AdidasShoes());
	}
};

抽象工厂模式

抽象工厂实例

//产品抽象类（鞋子 衣服）
class Shoes {
public:
	virtual ~Shoes() {}
	virtual void shoesProduction() = 0;
};

class Clothes {
public:
	virtual ~Clothes() {}
	virtual void clothesProduction() = 0;
};

//具体的产品
class NikeShoes :public Shoes {
public:
	virtual void shoesProduction() override
	{
		std::cout << "Nike shoes!" << std::endl;
	}
};

class NikeClothes :public Clothes {
public:
	virtual void clothesProduction() override
	{
		std::cout << "Nike clothes!" << std::endl;
	}
};

class AdidasShoes :public Shoes {
public:
	virtual void shoesProduction() override
	{
		std::cout << "Adidas shoes" << std::endl;
	}
};

class AdidasClothes :public Clothes {
public:
	virtual void clothesProduction() override
	{
		std::cout << "Adidas clothes" << std::endl;
	}
};

//工厂抽象类
class ShoesFactory {
public:
	virtual ~ShoesFactory() {}
	virtual std::shared_ptr<Shoes> createShoes() = 0;
	virtual std::shared_ptr<Clothes> createClothes() = 0;
};

//具体的产品生产线
class NikeFactory :public ShoesFactory {
public:
	virtual std::shared_ptr<Shoes> createShoes() override
	{
		std::cout << "Nike Shoes Factory" << std::endl;
		return std::shared_ptr<Shoes>(new NikeShoes());
	}
	virtual std::shared_ptr<Clothes> createClothes() override
	{
		std::cout << "Nike Clothes Factory" << std::endl;
		return std::shared_ptr<Clothes>(new NikeClothes());
	}
};

class AdidasFactory :public ShoesFactory {
public:
	virtual std::shared_ptr<Shoes> createShoes() override
	{
		std::cout << "Adidas Factory" << std::endl;
		return std::shared_ptr<Shoes>(new AdidasShoes());
	}
	virtual std::shared_ptr<Clothes> createClothes() override
	{
		std::cout << "Adidas Clothes Factory" << std::endl;
		return std::shared_ptr<Clothes>(new AdidasClothes());
	}
};

区别

适配器模式

• 定义：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
• 分为两种类型：类适配器模式 对象适配器模式
• 使用情况并不是有不同就使用适配器模式，而是在两者都不容易修改为对方的时候再进行适配器的使用
  

stack queue（容器适配器）

• 修饰deque的接口而成就出另一种容器风貌
• stack/queue 封住了deque的所有对外接口，只开放符合stack/queue原则的函数
• stack/queue时配接器，一个作用域容器之上的配接器