• 配置器将首先判断块的大小，大于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());
	}
};

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

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