特殊类设计

1，设计一个类，让该类不能被拷贝

//C++ 98 中将拷贝构造和赋值设置成私有（禁止类外面访问）
//       只声明不定义，因为不会被调用，所以定义没有意义
class A
{
private:
	A(const A&);
	A& operator=(const A&);
};

//C++11 引入了关键字delete，表示让编译器删除掉该默认成员函数
class B
{
	B(const B&) = delete;
	B& operator=(const B&) =delete;
};

2. 请设计一个类，只能在堆上创建对象

class C
{
public:
	//如果这里不是静态的，需要传值给this指针
	//然而对象还未在堆创建，又如何传呢？鸡生蛋，蛋生鸡。
	//所以这里静态的成员函数解决了这个问题
	static C* CreateObject() 
	{
		return new C;
	}

private:
	C()
	{
		cout << "C()" << endl;
	}

	//如果通过拷贝构造和复制重载去创建对象会在栈上,要处理一下
	C(const C&) = delete;  
	C& operator=(const C&) = delete;
};

3. 请设计一个类，只能在栈上创建对象

class D
{
public:
	static D CreateObj()
	{
		return D();
	}

	//operaotr new和operator delete不会调用构造函数就可以生成对象
	void* operator new(size_t size) = delete;	
	void operator delete(void* p)= delete ;

private:
	D()
	{}
};

4. 请设计一个类，不能被继承

C++ 98 构造函数私有化，父类无法调用子类的构造函数，无法被继承

C++11方法
final修饰类，表示该类不能被继承，

class E  final
{

};

设计一个类，让其只能创建一个对象。

设计模式：是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
单例模式：一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个
访问它的全局访问点，该实例被所有程序模块共享。

单例模式实现的两种方式：饿汉模式和懒汉模式
饿汉模式：在main（）函数执行之前就创建一个实例对象，不管用不用
优点：简单
缺点：如果实例对象时构造函数复杂，需要大量工作，可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定

懒汉模式：第一次调用实例化对象
优点：进程启动无负载。多个单例实例启动顺序自由控制。
缺点：复杂

//饿汉模式

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return _inst;
	}

	void Print()
	{
		cout << " hahaha" << endl;
	}

	 //防止拷贝和赋值去调用构造函数去实例化其他对象
     Singleton(const Singleton&) = delete;
	 Singleton& operator=(const Singleton&) = delete;
private:
	Singleton()
	{
	//少量的初始化工作
	}
	static Singleton* _inst;
};

//这个在main函数之前就已经初始化完成了
Singleton* Singleton::_inst = new Singleton;

//懒汉模式

class Singleton
{
public:
	static Singleton* GetInstace()
	{
		//双重锁
		if (_inst == nullptr)  //这个锁保证效率
		{
			_mux.lock();  //这个锁保证的是线程安全
			_inst = new Singleton;
			_mux.unlock();
		}
		
		return _inst;
	}

	~Singleton()
	{
		//析构只需要用一次，所以这里用一个垃圾回收类
	}

	class CGarbo   //内部类相当于是友元类，可以访问类的私有变量
	{
	public:
		~CGarbo()
		{
			if (_inst)
			{
				delete _inst;
				_inst = nullptr;
			}
		}
	};


	 Singleton(const Singleton&) = delete;
     Singleton& operator=(const Singleton&) = delete;

private:
	Singleton()
	{
		//大量的初始化工作
	}

	static Singleton* _inst;
	static mutex _mux;
	static CGarbo CG;   //定义一个静态的成员变量，程序结束的时候自动调用析构函数
	                   //完成单例类的释放
};

Singleton* Singleton::_inst = nullptr;
mutex Singleton::_mux;
Singleton::CGarbo Singleton::CG;

//懒汉模式2，
//缺点：静态区比较小，不适合大的类对象
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		static Singleton inst;  //借助静态的局部变量
		return &inst;
	}


	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton) = delete;
private:
	Singleton()
	{ 
      //大量的初始化工作
	}
};