C++特殊类与单例模式

一、特殊类

类的特殊设计方式

①不能被拷贝的类

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

在C++98中，需要将拷贝构造设置成私有，并且只声明不定义，是因为该构造函数根本不会调用，定义了也并无意义

//不能被拷贝的类
//C++98
class CopyBan
{

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

//C++11
class CopyBan
{
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
};

②只能在堆上创建对象的类

实现方法：

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

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

//只能在堆上创建对象的类
class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly() {}
	HeapOnly(const HeapOnly&);//C++98
	HeapOnly(const HeapOnly&) = delete;//C++11
};

③只能在栈上创建对象的类

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

禁用operator new可以把下面用new 调用拷贝构造申请对象给禁止

//只能在栈上创建对象的类
class StackOnly
{
public:
	static StackOnly CreateObject(int x=0)
	{
		return StackOnly(x);
	}

	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;

	StackOnly(StackOnly&& st)
		//拷贝构造被禁止之后，会导致创建StackOnly st1=StackOnly::CreateObj(1)失败，因此需要开放移动构造
		//但这样又会导致static StackOnly st2=move(st1)构造成功，因此并不能完全禁止
		:_x(st._x)
	{}
private:
	StackOnly(int x=0)
		:_x(x)
	{}

	StackOnly(const StackOnly& st) = delete;//禁止静态对象拷贝

private:
	int _x;
};

④不能被继承的类

//不能被继承的类
//C++98
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit() {}
};

//C++11
class A final
{

};

二、单例模式

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保障代码的可靠性

单例模式：一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享

单例模式有两种实现模式：饿汉模式和懒汉模式

饿汉模式：

饿汉模式是指：不论未来是否使用，在main函数执行之前，就已经生成一个实例

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避 免资源竞争，提高响应速度更好

饿汉式是线程安全的，在类创建的同时就已经创建好一个静态的对象供系统使用，以后不在改变。

#include<iostream>
#include<mutex>
#include<thread>
#include<vector>
#include<string>
#include<time.h>
using namespace std;

//单例对象：只能创建一个对象的类


//饿汉模式
//在main函数程序执行之前，就已经有了一个实例
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return _ins;
	}

	void Add(const string& str)
	{
		_mtx.lock();

		_v.push_back(str);

		_mtx.unlock();
	}

	void Print()
	{
		_mtx.lock();
		
		for (auto& e : _v)
		{
			cout << e << endl;
		}
		cout << endl;
		
		_mtx.unlock();
	}
private:
	Singleton() {};//限制类外随意创建对象

	//C++98防止拷贝
	//Singleton(Singleton const&);
	//Singleton& operator=(Singleton const&);

	//C++11防拷贝
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;
	
private:
	static Singleton* _ins;

	mutex _mtx;
	vector<string> _v;
};

Singleton* Singleton::_ins=new Singleton;//在程序入口之前，就完成对单例对象的初始化




int main()
{
	srand(time(0));

	int n = 30;
	thread t1([n]() {
		for (size_t i = 0; i < n; ++i)
		{
			Singleton::GetInstance()->Add("t1线程:" + to_string(rand()));
		}
		});

	thread t2([n]() {
		for (size_t i = 0; i < n; ++i)
		{
			Singleton::GetInstance()->Add("t2线程:" + to_string(rand()));
		}
		});

	t1.join();
	t2.join();

	Singleton::GetInstance()->Print();
	return 0;
}

懒汉模式：

懒汉模式顾名思义：只有在第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制

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

懒汉模式的实现相比于饿汉模式更加复杂。既然是手动启用实例，就需要考虑手动释放实例问题，手动释放实例之后不能影响自动释放实例，并且也不能重复释放

自动释放问题：定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象

懒汉模式中需要考虑线程安全问题：因此设计双检查加锁，第一次检查用于提高效率，避免每次访问单例都加减锁；第二次检查用于保证线程安全并确保单例只new一次

私有类内有两个锁，一个全局锁一个局部锁，全局锁存在的目的是使得单例获取与释放时都全局同一，保障全局唯一单例

#include<iostream>
#include<mutex>
#include<thread>
#include<vector>
#include<string>
#include<time.h>
using namespace std;

//懒汉模式
//第一次调用时才会创建单例
class Singleton
{
public:

	~Singleton()
	{
		//程序可能有持久化需求，要求在程序结束时，将数据写到文件中
	}
	static Singleton* GetInstance()
	{
		//双检查加锁
		if (_ins == nullptr)//用于提高效率 避免每次访问单例都加减锁
		{
			_imtx.lock();

			if (_ins == nullptr)//保证线程安全和只new一次
			{
				_ins = new Singleton;
			}

			_imtx.unlock();
		}
		return _ins;
	}


	void Add(const string& str)
	{
		_vmtx.lock();

		_v.push_back(str);

		_vmtx.unlock();
	}

	void Print()
	{
		_vmtx.lock();

		for (auto& e : _v)
		{
			cout << e << endl;
		}
		cout << endl;

		_vmtx.unlock();
	}




	//显示手动释放单例
	static void DelInstance()//一般全局都要使用单例对象，所以一般情况下不需要显示释放
	{
		_imtx.lock();
		if (_ins)
		{
			delete _ins;
			_ins = nullptr;//显示释放后置空，这样自动释放重复也不影响
		}
		_imtx.unlock();
	}

	//保证单例对象的回收（自动回收）
	class GC
	{
	public:
		~GC()
		{
			DelInstance();
		}
	};

	static GC _gc;

private:
	Singleton() {}//限制类外随意创建对象
	//没有处理拷贝构造，是由于锁的存在，默认生成的拷贝构造
	//实际上仍然需要防拷贝
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;

private:
	mutex _vmtx;
	vector<string> _v;

	static Singleton* _ins;//静态成员类外实现
	static mutex _imtx;
};

Singleton* Singleton::_ins = nullptr;
mutex Singleton::_imtx;

Singleton::GC Singleton::_gc;


int main()
{
	srand(time(0));

	int n = 30;
	thread t1([n]() {
		for (size_t i = 0; i < n; ++i)
		{
			Singleton::GetInstance()->Add("t1线程:" + to_string(rand()));
		}
		});

	thread t2([n]() {
		for (size_t i = 0; i < n; ++i)
		{
			Singleton::GetInstance()->Add("t2线程:" + to_string(rand()));
		}
		});

	t1.join();
	t2.join();

	Singleton::GetInstance()->Print();

	return 0;
}