c++特殊类

#include
#include
using namespace std;
//只能在堆上创建对象
//1.构造函数私有(防止在栈和数据段进行创建对象)
//2.ban掉构造函数和赋值运算符
//3.提供创建对象的方法(必须为静态,否则类名+::掉不动)
class HeapOnly
{
public:
static HeapOnly* create()
{
return new HeapOnly;
}
private:
HeapOnly()
{}
HeapOnly(const HeapOnly& a) = delete;
HeapOnly& operator=(const HeapOnly& a) = delete;
};
//只能在栈上创建对象
//1.将构造函数设置为私有
//2.尽调new 方法
//3.提供在栈上创建对象的的方法
class StackOnly
{
public:
static StackOnly& create()
{
return StackOnly();
}
private:
StackOnly(){};
void* operator new(size_t size)=delete;
};
//防止拷贝
//尽调复制运算符重载和拷贝构造即可
class NotCopy
{
private:
NotCopy(const NotCopy& ncp) = delete;
NotCopy& operator =(const NotCopy& ncp) = delete;
};
//防止继承
//将类设置为final即可
class NoH2 final
{};

//饿汉模式
//构造函数设置为私有
//ban掉拷贝构造和复制运算符重载
//在数据段创建一个类对象,注意不能直接在栈上创建,否则会一起无线递归创建的情况
//提供创建对象的方法(把之前在数据段创建的对象赋值给所要创建的对象即可)
//好处:多线程运行效率高
//缺点:程序启动缓慢(程序启动之前必须在数据段先把对象创建好) ,初始化顺序不确定(由编译器自己决定)
class singleton
{
public:
singleton& create()
{
return _single;
}
private:
singleton(){};
singleton(const singleton& sig) = delete;
singleton& operator = (const singleton& sig) = delete;
static singleton _single;
};
与饿汉模式的来者不拒相对应,懒汉模式是在第一次访问过程中,程序运行期间创建对象的,它的启动速度得到了很大的优化,但是实现起来也略显复杂
//懒汉模式
//1.ban掉构造函数,拷贝构造,赋值运算符重载
//2.声明一个静态类对象指针,并初始化为nullptr
//3.当第一此调用时,就创建对象并且返回,以后直接返回
//4.考虑到多线程,同时创建单例的问题,所以要在创建对象的前后加锁
//5.由于每次创建对象都要加锁解锁效率非常的低,因此我们可以先判断是否需要加锁,有考虑到如果多线程同时进入的情况,
//因此我们这里需要判断两次
mutex mux;
class singleton2
{
public:
singleton2* create()
{
if (ptrnullptr)
{
if (ptrnullptr)
//第一次调用,创建对象
//由于多线程下可能会同时进入这里,从而造成创建多个单例的特殊情况,所以我们要在这里加锁
{
mux.lock();
ptr = &singleton2();
mux.unlock();
}
}
//后续调用会直接返回
return ptr;
}
private:
singleton2(){};
singleton2(const singleton2& single) = delete;
singleton2& operator = (const singleton2& single) = delete;
static singleton2* ptr;
};
singleton2* singleton2::ptr = nullptr;