【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做法的原因：

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

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

只能在堆上创建对象

实现原理：

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

代码实现：

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
{
// ....
};

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

饿汉模式

原理：

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

代码实现：

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;
}

优点：简单
问题：

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

懒汉模式

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

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

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

代码实现：

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;
}