博客主页: 主页
系列专栏: C++
❤️感谢大家点赞收藏⭐评论✍️
期待与大家一起进步!
实现方式:
- 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建
class HeapOnly
{
public:
static HeapOnly* CreateObj()
{
return new HeapOnly;
}
private:
HeapOnly()
{
//...
}
HeapOnly(const HeapOnly& hp) = delete;
HeapOnly& operator=(const HeapOnly& hp) = delete;
};
实现方法:
1.同上将构造函数私有化,然后设计静态方法创建对象返回即可
2.禁用堆上的创建方式,new=operator new+构造函数
3.operator new 是系统提供的全局函数,new在底层调用operator new全局函数来申请空间
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
// StackOnly obj = StackOnly::CreateObj();
// StackOnly* ptr3 = new StackOnly(obj);
// new==operator new + 构造
//delete==析构+operator delete
void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;
private:
//构造函数私有化
//拷贝构造函数不能私有化,因为我们上面CreateObj()返回,需要
//用到拷贝构造函数
StackOnly()
:_a(0)
{}
private:
int _a;
};
// 构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
//final关键字,final修饰类,表示该类不能被继承。
class A final
{
// ....
};
单例模式:
一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。 比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理
就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。
class Singleton
{
public:
// 2、提供获取单例对象的接口函数
static Singleton& GetInstance()
{
return _sinst;
}
private:
// 1、构造函数私有
//构造函数私有也不能调用new了
Singleton()
{
// ...
}
// 3、防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
static Singleton _sinst;
//虽然为静态类型,但依然可以使用对应类里面的构造函数
};
Singleton Singleton::_sinst;// 在程序入口之前就完成单例对象的初始化
饿汉模式:一开始(main函数之前)就创建单例对象
1、如果单例对象初始化内容很多,影响启动速度
2、如果两个单例类,互相有依赖关系。
假设有A B两个单例类,要求A先创建,B再创建,B的初始化创建依赖A,但在main的外面没办法确定哪个类先被创建,可能会出现问题
如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。
class Singleton
{
public:
// 2、提供获取单例对象的接口函数
static Singleton& GetInstance()
{
if (_psinst == nullptr)
{
// 第一次调用GetInstance的时候创建单例对象
_psinst = new Singleton;
}
return *_psinst;
}
private:
// 1、构造函数私有
Singleton()
{
// ...
}
~Singleton()
{
}
// 3、防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
static Singleton* _psinst;
};
Singleton* Singleton::_psinst = nullptr;
static void DelInstance()
{
if (_psinst)
{
delete _psinst;
_psinst = nullptr;
}
//自己写一个静态的函数,进行释放操作
}
方法:
1.我们把要写入的数据过程放到析构函数中
2.我们可以像智能指针那样使用,在类里面再定义一个类GC,让GC的析构函数专门用来管理Singleton的析构函数,然后创建GC的对象,因为GC不是指针类型为普通类型,程序结束的时候会自动调用其析构函数,这样也就完成了Singleton的析构函数
class GC
{
public:
~GC()
{
Singleton::DelInstance();
}
};
~Singleton()
{
cout << "~Singleton()" << endl;
// map数据写到文件中
FILE* fin = fopen("map.txt", "w");
for (auto& e : _dict)
{
fputs(e.first.c_str(), fin);
fputs(":", fin);
fputs(e.second.c_str(), fin);
fputs("\n", fin);
}
}
class Singleton
{
public:
// 2、提供获取单例对象的接口函数
static Singleton& GetInstance()
{
if (_psinst == nullptr)
{
// 第一次调用GetInstance的时候创建单例对象
_psinst = new Singleton;
}
return *_psinst;
}
// 一般单例不用释放。
// 特殊场景:1、中途需要显示释放 2、程序结束时,需要做一些特殊动作(如持久化)
static void DelInstance()
{
if (_psinst)
{
delete _psinst;
_psinst = nullptr;
}
}
class GC
{
public:
~GC()
{
Singleton::DelInstance();
}
};
private:
// 1、构造函数私有
Singleton()
{
// ...
}
~Singleton()
{
cout << "~Singleton()" << endl;
// map数据写到文件中
FILE* fin = fopen("map.txt", "w");
for (auto& e : _dict)
{
fputs(e.first.c_str(), fin);
fputs(":", fin);
fputs(e.second.c_str(), fin);
fputs("\n", fin);
}
}
// 3、防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
map<string, string> _dict;
// ...
static Singleton* _psinst;
static GC _gc;
};
Singleton* Singleton::_psinst = nullptr;
Singleton::GC Singleton::_gc;
class A {
public:
A() {
cout << "gouzao" << endl;
}
~A() {
cout << "析构函数" << endl;
}
};