只能在堆上创建对象,也就是只能通过new操作符创建对象,方式如下:
代码如下:
class HeapOnly
{
public:
//2、提供一个获取对象的接口,并且该接口必须设置为静态成员函数
static HeapOnly* CreateObj()
{
return new HeapOnly;
}
private:
//1、将构造函数设置为私有
HeapOnly()
{}
//3、将拷贝构造函数设置为私有,并且只声明不实现
//C++98
HeapOnly(const HeapOnly&);
//C++11
//HeapOnly(const HeapOnly&) = delete;
};
说明一下:
=delete
,表示让编译器将拷贝构造函数删除,此时也能达到防拷贝的目的。方法一
方式如下:
代码如下:
class StackOnly
{
public:
//2、提供一个获取对象的接口,并且该接口必须设置为静态成员函数
static StackOnly CreateObj()
{
return StackOnly();
}
private:
//1、将构造函数设置为私有
StackOnly()
{}
};
但该方法有一个缺陷就是,无法防止外部调用拷贝构造函数创建对象。
StackOnly obj1 = StackOnly::CreateObj();
static StackOnly obj2(obj1); //在静态区拷贝构造对象
StackOnly* ptr = new StackOnly(obj1); //在堆上拷贝构造对象
但是我们不能将构造函数设置为私有,也不能用=delete
的方式将拷贝构造函数删除,因为CreateObj函数当中创建的是局部对象,返回局部对象的过程中势必需要调用拷贝构造函数。
方法二
方式如下:
代码如下:
class StackOnly
{
public:
StackOnly()
{}
private:
//C++98
void* operator new(size_t size);
void operator delete(void* p);
//C++11
//void* operator new(size_t size) = delete;
//void operator delete(void* p) = delete;
};
new和delete的原理:
new和delete默认调用的是全局的operator new函数和operator delete函数,但如果一个类重载了专属的operator new函数和operator delete函数,那么new和delete就会调用这个专属的函数。所以只要把operator new函数和operator delete函数屏蔽掉,那么就无法再使用new在堆上创建对象了。
但该方法也有一个缺陷,就是无法防止外部在静态区创建对象。
static StackOnly obj; //在静态区创建对象
当然,你也可以将方法一和方法二进行结合,结合之后就只是无法防止在静态区拷贝构造对象了。
要让一个类不能被拷贝,就要让该类不能调用拷贝构造函数和赋值运算符重载函数,因此直接将该类的拷贝构造函数和赋值运算符重载函数设置为私有,或者用C++11的方式将这两个函数删除即可。
代码如下:
class CopyBan
{
public:
CopyBan()
{}
private:
//C++98
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//C++11
//CopyBan(const CopyBan&) = delete;
//CopyBan& operator=(const CopyBan&) = delete;
};
方法一:C++98
将该类的构造函数设置为私有即可,因为子类的构造函数被调用时,必须调用父类的构造函数初始化父类的那一部分成员,但父类的私有成员在子类当中是不可见的,所以在创建子类对象时子类无法调用父类的构造函数对父类的成员进行初始化,因此该类被继承后子类无法创建出对象。
代码如下:
class NonInherit
{
public:
static NonInherit CreateObj()
{
return NonInherit();
}
private:
//将构造函数设置为私有
NonInherit()
{}
};
方法二:C++11
C++98的这种方式其实不够彻底,因为这个类仍然可以被继承(编译器不会报错),只不过被继承后无法实例化出对象而已。于是C++11中提供了final关键字,被final修饰的类叫做最终类,最终类无法被继承,此时就算继承后没有创建对象也会编译出错。
代码如下:
class NonInherit final
{
//...
};
什么是单例模式?
单例模式有两种实现方式,分别是饿汉模式和懒汉模式:
饿汉模式
单例模式的饿汉实现方式如下:
代码如下:
class Singleton
{
public:
//3、提供一个全局访问点获取单例对象
static Singleton* GetInstance()
{
return _inst;
}
private:
//1、将构造函数设置为私有,并防拷贝
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
//2、提供一个指向单例对象的static指针
static Singleton* _inst;
};
//在程序入口之前完成单例对象的初始化
Singleton* Singleton::_inst = new Singleton;
线程安全相关问题:
懒汉模式
单例模式的懒汉实现方式如下:
代码如下:
class Singleton
{
public:
//3、提供一个全局访问点获取单例对象
static Singleton* GetInstance()
{
//双检查
if (_inst == nullptr)
{
_mtx.lock();
if (_inst == nullptr)
{
_inst = new Singleton;
}
_mtx.unlock();
}
return _inst;
}
private:
//1、将构造函数设置为私有,并防拷贝
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
//2、提供一个指向单例对象的static指针
static Singleton* _inst;
static mutex _mtx; //互斥锁
};
//在程序入口之前先将static指针初始化为空
Singleton* Singleton::_inst = nullptr;
mutex Singleton::_mtx; //初始化互斥锁
线程安全相关问题:
双检查加锁:
饿汉模式和懒汉模式对比
其他版本的懒汉
懒汉模式还有一种比较经典的实现方式:
代码如下:
class Singleton
{
public:
//2、提供一个全局访问点获取单例对象
static Singleton* GetInstance()
{
static Singleton inst;
return &inst;
}
private:
//1、将构造函数设置为私有,并防拷贝
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
在单例类的GetInstance函数中定义一个静态的单例对象并返回。
这种版本的懒汉主要有如下两个缺点:
单例对象的释放
单例对象创建后一般在整个程序运行期间都可能会使用,所以我们可以不考虑单例对象的释放,程序正常结束时会自动将资源归还给操作系统。
如果要考虑单例对象的释放,可以参考以下两种方式:
代码如下:
static void DelInstance()
{
_mtx.lock();
if (_inst != nullptr)
{
delete _inst;
_inst = nullptr;
}
_mtx.unlock();
}
代码如下:
//垃圾回收类
class CGarbo
{
public:
~CGarbo()
{
if (_inst != nullptr)
{
delete _inst;
_inst = nullptr;
}
}
};