【C++进阶】特殊类设计 && 单例模式

不能被拷贝的类

//C++98
class CopyBan
{
public:

private:
	CopyBan(const CopyBan&){};
	const CopyBan& operator=(const CopyBan&){};
};

//C++11
class CopyBan
{
public:
	CopyBan(const CopyBan&) = delete;
	const CopyBan& operator=(const CopyBan&) = delete;
private:

};

C++98做法的原因：

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

C++11就直接删除该默认成员函数！

只能在堆上创建对象

实现原理：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

代码实现：

class HeapOnly
{
public:
	static HeapOnly* CreateObjeckt()
	{
		return new HeapOnly;
	}
	HeapOnly(const HeapOnly&) = delete;
	HeapOnly& operator=(const HeapOnly&) = delete;
private:
	HeapOnly() {};
};

int main()
{
	//都被禁止创建栈上的对象
	/*HeapOnly h1;
	static HeapOnly h2;
	HeapOnly* h3 = new HeapOnly;*/

	HeapOnly* h4 = HeapOnly::CreateObjeckt();

	return 0;
}

只能在栈上创建对象

同上将构造函数私有化，然后设计静态方法创建对象返回即可。

class StackOnly
{
public:
	static StackOnly CreateObjeckt()
	{
		return StackOnly();
	}
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	StackOnly(){};
};

int main()
{
	// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
	StackOnly obj1 = StackOnly::CreateObjeckt();
	//StackOnly* obj2 = new StackOnly(obj1);

	return 0;
}

不能被继承的类

C++98方式
C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承

//C++98方式
class NonInherit // Inherit继承
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit(){};
};

C++11方式
final关键字，final修饰类，表示该类不能被继承。

class A final
{
// ....
};

只能创建一个对象（单例模式）

饿汉模式

原理：

1. 一开始就创建对象（main函数之前）
2. 只创建一个对象并且是私有静态成员对象，禁止拷贝构造和赋值重载。
3. 提供全局的访问点

代码实现：

class PeopleInfo
{
public:
	static PeopleInfo* GetInstance()
	{
		return &_pinfo;
	}

private:
	PeopleInfo()
	{};
	PeopleInfo(const PeopleInfo&) = delete;
	PeopleInfo& operator=(const PeopleInfo&) = delete;
private:
	string _name = "xxx";
	int _age = 0;
	//...

	//声明
	static PeopleInfo _pinfo;
};

//定义
PeopleInfo PeopleInfo::_pinfo;

int main()
{
	cout << PeopleInfo::GetInstance() << endl;
	cout << PeopleInfo::GetInstance() << endl;
	cout << PeopleInfo::GetInstance() << endl;
	return 0;
}

优点：简单
问题：

1. main函数之前就创建对象
2. 假如同时创建很多单例类，有些单例对象初始化资源很多，导致程序启动缓慢，迟迟不进入main函数。
3. 如果两个单例类有初始化依赖关系，比如A类和B类是单例，A类要连接数据库，B单例要用A单例访问数据库，那谁先初始化呢，我们无法确定！
   所以就有了懒汉模式

懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，
初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。
所以这种情况使用懒汉模式（延迟加载）更好。

懒汉模式完美解决了上述问题
原理：

1. 第一次调用GetInstance时创建对象。
2. 构造依旧私有，拷贝构造和赋值重载删除掉。
3. 提供全局的访问点。

代码实现：

class PeopleInfo
{
public:
	static PeopleInfo* GetInstance()
	{
		static PeopleInfo pinfo;

		return &pinfo;
	}

private:
	PeopleInfo()
	{};
	PeopleInfo(const PeopleInfo&) = delete;
	PeopleInfo& operator=(const PeopleInfo&) = delete;
private:
	string _name = "xxx";
	int _age = 0;
	//...
};

int main()
{
	cout << PeopleInfo::GetInstance() << endl;
	cout << PeopleInfo::GetInstance() << endl;
	cout << PeopleInfo::GetInstance() << endl;
	return 0;
}

但是上述代码又会带来新的问题，假如是在多线程情况下跑呢？
我们就需要考虑线程安全的问题！！！
上述写法C++11之前不能用，局部静态单例对象构造初始化无法保证线程安全问题，C++11后可以用，C++11之后进行了优化，就不会出现线程安全的问题了！
但是要更稳妥，我们还是对代码进行一些优化
C++11之前也能保证是线程安全的：
代码实现：

#include<mutex>
class PeopleInfo
{
public:
	static PeopleInfo* GetInstance()
	{
		if (_pinfo == nullptr)//保证性能，下次线程再进来就不会重复加锁了！！！
		{
			unique_lock<mutex> lock(_mtx);//保证线程安全
			if (_pinfo == nullptr)
			{
				_pinfo = new PeopleInfo;
			}
		}
		return _pinfo;
	}

private:
	PeopleInfo()
	{};
	PeopleInfo(const PeopleInfo&) = delete;
	PeopleInfo& operator=(const PeopleInfo&) = delete;
private:
	string _name = "xxx";
	int _age = 0;
	//...

	static PeopleInfo* _pinfo;
	static mutex _mtx;
};

PeopleInfo* PeopleInfo::_pinfo = nullptr;
mutex PeopleInfo::_mtx;
int main()
{
	cout << PeopleInfo::GetInstance() << endl;
	cout << PeopleInfo::GetInstance() << endl;
	cout << PeopleInfo::GetInstance() << endl;
	return 0;
}