C++特殊类与单例模式

模式"/>

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++98HeapOnly(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;
}