特殊类&单例模式

只能在堆上创建对象

实现方式：

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

//创建一个只是在堆上的对象
//将类的构造函数设置为私有——这样在类外就不方便创建全局或者局部的类了
class HeapOnly
{
public:
	//HeapOnly* CreatObj()//如果想获取对象，我们就要先调用成员函数
	static HeapOnly*CreatObj()//静态的成员对象就不需要对象
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{}
	//拷贝构造设置为私有，并且只声明不实现。
	//C++98防拷贝
	HeapOnly(const HeapOnly&);
	//C++11防拷贝
	HeapOnly(const HeapOnly&) = delete;//这里无论是否是私有，都可以防止拷贝
};
int main()
{
	/*HeapOnly ho;
	HeapOnly* p = new HeapOnly;*/
	HeapOnly* p = HeapOnly::CreatObj();
	//HeapOnly copy(*p);//可以利用拷贝构造去创建一个对象，我们我们需要将拷贝构造设置为私有
	return 0;
}

只能在栈上创建对象

1. 将构造函数私有化，然后设计静方法创建对象返回即可
2. 屏蔽new，因为new在底层调用void* operator new(size_t size)函数，只需将该函数屏蔽掉即可。注意：也要防止定位new

//只能在栈上创建对象
class StackOnly
{
	//将构造函数私有化，但是不能将拷贝函数也私有化，因为下面返回时需要拷贝构造
public:
	static StackOnly CreateObject()
	{
		return StackOnly();
	}
private:
	StackOnly() {}
};
//将operator new屏蔽掉，虽然不能在堆上创建对象，但是可以在静态区上创建
class StackOnly
{
public:
	StackOnly() {}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};

设计一个类，不能被拷贝

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

//设计一个类，不能被拷贝
//将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
//.设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
//只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，
//而且如果定义了就不会防止成员函数内部拷贝了。
//C++98
class CopyBan
{
	// ...

private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);
	//...
};
//C++11
//C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，
//表示让编译器删除掉该默认成员函数。
class CopyBan
{
	// ...
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
	//...
};

设计一个类，不能被继承

在C++98中：将构造函数私有化，这样派生类就无法调到基类的构造函数，则就无法继承

class NonInherit
{
public:
 static NonInherit GetInstance()
 {
 return NonInherit();
 }
private:
 NonInherit()
 {}
};

在C++11中：使用final关键字，final修饰类，表示该类不能被继承

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

单例模式

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

饿汉模式

饿汉模式是，不管将来用不用，程序启动时就创建一个唯一的实例对象
优点：简单
缺点：

1. 如果单例对象构造函数工作比较多，会导致程序启动慢，迟迟进不了入口main函数。
2. 如果有多个单例对象，他们之间有初始化依赖关系，饿汉模式也会有问题。比如有A和B两个单例类，要求A单例先初始化，B必须在A之后初始化，那么饿汉无法保证。

//单例模式
//如果要保证全局（一个进程中）只有一个唯一实例对象
//1、那么首先需要将构造函数私有化,拷贝构造和赋值防拷贝禁掉
//2、控制全局只有唯一一个 实例——饿汉模式、懒汉模式。
//饿汉模式——程序开始main执行之前就创建单例对象
//提供一个静态指向单例对象的成员指针，初始化时new一个对象给它
class Singleton
{
public:
	//获取实例对象
	//静态的成员函数没有this指针，而且只能访问静态的成员变量
	static Singleton*GetInstance()//返回实例对象
	{
		return _inst;
	}
	void print()
	{
		cout << "print()" << _a << endl;
	}
private:
	Singleton()
		:_a(0)
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	int _a;
	//虽然不能定义自己类的对象，但是可以定义自己类的指针
	static Singleton* _inst;

};
Singleton*Singleton::_inst =new Singleton;//静态的成员变量需要在类外进行初始化
int main()
{
	cout << Singleton::GetInstance() << endl;
	Singleton::GetInstance()->print();//Singleton::GetInstance()a先获得实例对象
	return 0;
}

懒汉模式

优点：解决上面饿汉的缺点，因为他是第一次调用GetInstance时创建初始化单例对象
缺点：相对饿汉，复杂一点点。

// 假设单例类构造函数中，要做很多配置初始化工作，那么饿汉就不适合了——会导致程序启动很慢
//懒汉模式——刚开始不会创建对象
#ifdef _WIN32
//windows 提供多线程api
#else
//Linux pthread
#endif // _WIN32

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		//保护第一次加锁，后面都不需要加锁的场景，可以使用双检查加锁
		//特点：第一次加锁，后面不加锁，保护线程安全，同时提高效率
		if (_inst == nullptr)
		{
			_mtx.lock();
			if (_inst == nullptr)
			{
				_inst = new Singleton;
			}
			_mtx.unlock();
		}
		return _inst;
	}
	void print()
	{
		cout << "print()" << _a << endl;
	}
private:
	Singleton()
		:_a(0)
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	int _a;
	
	static Singleton* _inst;
	static std::mutex _mtx;//定义一个静态的，这样不管谁来了都会访问到这个锁

};
Singleton* Singleton::_inst = nullptr;
std::mutex Singleton::_mtx;

int main()
{
	cout << Singleton::GetInstance() << endl;
	Singleton::GetInstance()->print();//Singleton::GetInstance()a先获得实例对象
	return 0;
}