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
#include
#include
#include
#include
#include
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 _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
#include
#include
#include
#include
#include
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 _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;
}