设计特殊类、单例模式（懒汉模式，饿汉模式）

1、设计一个类，只能在堆上创建对象

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

   class HeapOnly
   {
   public:
   	static HeapOnly* GetInstance()
   	{
   		HeapOnly* p = new HeapOnly;
   		return p;
   	}
   private:
   	HeapOnly()
   	{
   		cout << "HeapOnly()" << endl;
   	}
   
   	HeapOnly(const HeapOnly& obj) = delete;
   };
   

2、设计一个类，只能在栈上创建对象

方法① - - >实现方式：

1. 同上将构造函数私有化，然后设计静态成员函数中创建对象返回。

class StackOnly
{
public:
	static StackOnly GetInstance()
	{
		return StackOnly();
	}
private:
	StackOnly()
	{
		cout << "StackOnly()" << endl;
	}
};

方法② - - >实现方式：屏蔽new

1. 因为new在底层调用void* operator new(size_t size)函数，只需将该函数屏蔽掉。

   class StackOnly
   {
   public:
   	StackOnly()
   	{
   		cout << "StackOnly()" << endl;
   	}
   private:
   	void* operator new(size_t size);
   	void operator delete(void* ptr);
   };
   

3、设计一个类，不能被拷贝

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类 不能调用拷贝构造函数以及赋值运算符重载。

• C++98
  将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有。

  class copy
  {
  private:
  	copy(const copy& obj);
  	copy& operator=(const copy& obj);
  };
  

  原因：

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝 了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简 单，而且如果定义了就不会防止成员函数内部拷贝了。

• C++11
  C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表 示让编译器删除掉该默认成员函数。

	class copy
	{
	private:
		copy(const copy& obj) = delete;
		copy& operator=(const copy& obj) = delete;
	};

3、设计一个类，不能被继承

• C++98
  构造函数私有化，派生类中调不到基类的构造函数。则无法继承 。
• C++11
  使用 final 关键字，定义一个最终类，表示该类不能被继承。

4、单例模式

• 饿汉模式
  程序启动时就创建一个唯一的实例对象。

  class singleton
  {
  public:
  	singleton& GetInstance()
  	{
  		return obj;
  	}
  private:
  	static singleton obj;
  
  	singleton(){}
  
  	singleton(const singleton& obj) = delete;
  	singleton& operator=(const singleton& obj) = delete;
  };
  singleton singleton::obj;//mian函数之前就需要创建初始化这个实例对象
  

  饿汉模式不加锁的情况下是否是线程安全的？

  饿汉模式在多线程下是安全的的，因为在main函数之前就已经创建初始化了这个对象。

• 懒汉模式
  知道真正需要使用对象的时候才会去创建对象。

  class singleton
  {
  public:
  	static singleton& GetInstance()
  	{
  		if (_InstancePtr == nullptr)//此处检验是为了避免频繁加锁带来的低效率问题
  		{
  			_mutex.lock();//加锁是为了保证线程安全
  			if (_InstancePtr == nullptr)
  			{
  				_InstancePtr = new singleton;
  			}
  			_mutex.unlock();
  		}
  		return *_InstancePtr;
  	}
  private:
  
  	static singleton* _InstancePtr;
  	static mutex _mutex;
  
  	singleton(){};
  	singleton(const singleton& obj) = delete;
  	singleton& operator=(const singleton& obj) = delete;
  };
  

  懒汉模式注意：

  1、加锁解锁的位置，保证初始化加载过程线程安全 。
  2、双重 if 判定, 避免不必要的锁竞争，降低程序效率。

  懒汉模式在加锁的情况下才能保证线程安全！

饿汉模式与懒汉模式的区别？

• 饿汉模式的优缺点

  优点：实现相对简单，初始化时资源直接加载，因此运行时性能会比较高以及运行比较流畅。多线程安全，无需加锁。

  缺点：将当前不用的资源也加载到内存中，因此资源消耗比较大，初始化阶段耗时比较长。

• 懒汉模式的优点

  优点：初始化比较快，在运行阶段使用的时候也只需要加载一次。
  缺点：实现相对复杂，为保证多线程安全需要加锁，损失了性能。