【初阶与进阶C++详解】第二十六篇:特殊类设计(单例模式)

个人主页:企鹅不叫的博客

专栏

  • C语言初阶和进阶
  • C项目
  • Leetcode刷题
  • 初阶数据结构与算法
  • C++初阶和进阶
  • 《深入理解计算机操作系统》
  • 《高质量C/C++编程》
  • Linux

⭐️ 博主码云gitee链接:代码仓库地址

⚡若有帮助可以【关注+点赞+收藏】,大家一起进步!

系列文章

【初阶与进阶C++详解】第一篇:C++入门知识必备

【初阶与进阶C++详解】第二篇:C&&C++互相调用(创建静态库)并保护加密源文件

【初阶与进阶C++详解】第三篇:类和对象上(类和this指针)

【初阶与进阶C++详解】第四篇:类和对象中(类的六个默认成员函数)

【初阶与进阶C++详解】第五篇:类和对象下(构造+static+友元+内部类

【初阶与进阶C++详解】第六篇:C&C++内存管理(动态内存分布+内存管理+new&delete)

【初阶与进阶C++详解】第七篇:模板初阶(泛型编程+函数模板+类模板+模板特化+模板分离编译)

【初阶与进阶C++详解】第八篇:string类(标准库string类+string类模拟实现)

【初阶与进阶C++详解】第九篇:vector(vector接口介绍+vector模拟实现+vector迭代器区间构造/拷贝构造/赋值)

【初阶与进阶C++详解】第十篇:list(list接口介绍和使用+list模拟实现+反向迭代器和迭代器适配)

【初阶与进阶C++详解】第十一篇:stack+queue+priority_queue+deque(仿函数)

【初阶与进阶C++详解】第十二篇:模板进阶(函数模板特化+类模板特化+模板分离编译)

【初阶与进阶C++详解】第十三篇:继承(菱形继承+菱形虚拟继承+组合)

【初阶与进阶C++详解】第十四篇:多态(虚函数+重写(覆盖)+抽象类+单继承和多继承)

【初阶与进阶C++详解】第十五篇:二叉树搜索树(操作+实现+应用KVL+性能+习题)

【初阶与进阶C++详解】第十六篇:AVL树-平衡搜索二叉树(定义+插入+旋转+验证)

【初阶与进阶C++详解】第十七篇:红黑树(插入+验证+查找)

【初阶与进阶C++详解】第十八篇:map_set(map_set使用+multiset_multimap使用+模拟map_set)

【初阶与进阶C++详解】第十九篇:哈希(哈希函数+哈希冲突+哈希表+哈希桶)

【初阶与进阶C++详解】第二十篇:unordered_map和unordered_set(接口使用+模拟实现)

【初阶与进阶C++详解】第二十一篇:哈希应用(位图实现应用+布隆过滤器增删查优缺点+海量数据面试题)

【初阶与进阶C++详解】第二十二篇:C++11新特性(列表初始化+变量类型推到+右值引用+新增默认成员函数+可变模板参数+lambda表达式+包装器function_bind)

【初阶与进阶C++详解】第二十三篇:异常(异常抛出+异常捕获+异常优缺点)

【初阶与进阶C++详解】第二十四篇:智能指针(内存泄漏+RAII+auto_ptr+unique_ptr+shared_ptr+weak_ptr+定制删除器)

【初阶与进阶C++详解】第二十五篇:类型转换(static_cast+reinterpret_cast+const_cast+dynamic_cast+RTTI)


文章目录

  • 系列文章
  • 一、设计模式
  • 二、设计一个类,不能被拷贝
  • 三、设计一个类,不能被继承
  • 四、设计一个类,只能在堆上创建对象
  • 五、设计一个类,只能在栈上创建对象
  • 六、设计一个类,只能创建一个对象(单例模式)
    • 1.饿汉模式
    • 2.懒汉模式
    • 2.饿汉模式和懒汉模式区别


一、设计模式

设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

二、设计一个类,不能被拷贝

拷贝只会在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝,只需让该类不能调用拷贝构造函数以及赋值运算符重载即可

C++98:将拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可。

class CopyBan
{
	 // ...

private:
	 CopyBan(const CopyBan&);
	 CopyBan& operator=(const CopyBan&);
	 //...
};

原因:

  1. 设置成私有:如果只声明没有设置成private,用户自己如果在类外定义了,就可以不能禁止拷贝了
  2. 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。

C++11:C++11扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上=delete,表示让编译器删除掉该默认成员函数。

class CopyBan
{
	 // ...
	 CopyBan(const CopyBan&)=delete;
	 CopyBan& operator=(const CopyBan&)=delete;
	 //...
};

三、设计一个类,不能被继承

C++98:构造函数私有化,派生类中调不到基类的构造函数(派生类的构造函数,必须调用父类的构造函数初始化继承的父类成员,但是父类构造函数私有,派生类内不可见),则无法继承

// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
	static NonInherit GetInstance()
	 {
		return NonInherit();
	 }
private:
	 NonInherit()
	{}
};

C++11:final关键字,final修饰类,表示该类不能被继承。

class A final
{
	 // ....
};

四、设计一个类,只能在堆上创建对象

实现方式:

  1. 将类的构造函数私有,这样就无法在栈或堆上直接定义对象了。
  2. 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建(因为,构造函数私有,在外面不能调动,就需要成员函数去调动,而成员函数需要成员调动,但是不能创建成员,因此用一个静态函数去调用构造函数)。
  3. 创建出来的对象虽然是在堆上的,但是由于拷贝函数的存在,可能会拷贝到栈上,因此将拷贝构造声明为私有的且不实现,或者直接删除掉。
class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()   
    {}

	// C++98
	// 1.只声明,不实现。因为实现可能会很麻烦,而你本身不需要
	// 2.声明成私有
	HeapOnly(const HeapOnly&);

		// or

		// C++11 
	HeapOnly(const HeapOnly&) = delete;//直接删除
};

五、设计一个类,只能在栈上创建对象

同上将构造函数私有化,然后设计静态方法创建对象返回即可。

class StackOnly 
{ 
public: 
	 static StackOnly CreateObject() 
	 { 
		return StackOnly(); //构造一个匿名对象,拷贝返回即可
	 }
private:
	 StackOnly() {}
};

六、设计一个类,只能创建一个对象(单例模式)

单例模式:一个类只能在全局(进程中)创建一个实例对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。

1.饿汉模式

就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象

class Singleton
{
public:
	//提供一个共有接口,来获取这个对象
	static Singleton* GetInstance()
	{
		return _psln;
	}
private:
 // 构造函数私有
	Singleton()
	{}
 // C++11
	Singleton(const Singleton&) = delete;
	Singleton& operator=(Singleton&) = delete;
	//在private中创建一个static对象(声明),这个对象不属于这个类,是全局对象,但要受到这个域的限制
	static Singleton* _psln;//声明
};
// static对象在main函数之前创建,此时只有主线程,所以不存在线程安全的问题
Singleton Singleton::_psln = new Singleton;//定义

饿汉模式的特点:

  • 构造函数私有

  • 提供一个静态的方法返回单例

  • 声明一个静态的单例成员

  • 拷贝构造和赋值声明为delete函数

    饿汉模式的优缺点:

  • 优点:实现简单、多线程场景下效率高。

  • 缺点:程序启动慢、多个单例的初始化顺序是无法控制的。

    如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避免资源竞争,提高响应速度更好。

2.懒汉模式

如果单例对象构造十分耗时或者占用很多资源,比如加载插件, 初始化网络连接,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。

class InfoMgr
{
public:
	static InfoMgr* GetInstance()
	{
		// 还需要加锁,这个后面讲  -- 双检查加锁
		if (_spInst == nullptr)
		{
			_spInst = new InfoMgr;
		}

		return _spInst;
	}

	void SetAddress(const string& s)
	{
		_address = s;
	}

	string& GetAddress()
	{
		return _address;
	}

	// 实现一个内嵌垃圾回收类    
	class CGarbo //程序结束了,资源自然会还给系统,可写可不可
{
	public:
		~CGarbo(){
			if (_spInst)
				delete _spInst;
		}
	};

	// 定义一个静态成员变量,程序结束时,系统会自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;

private:
	InfoMgr()
	{}

	~InfoMgr()
	{
		// 假设析构时需要信息写到文件持久化
	}
	//拷贝、赋值需要禁掉
	InfoMgr(const InfoMgr&) = delete;
 InfoMgr& operator=(InfoMgr&) = delete;

	string _address;
	int _secretKey;
	// 声明一个静态成员变量,程序结束时,系统会自动调用它的析构函数从而释放单例对象
	static InfoMgr* _spInst; // 声明
};

InfoMgr* InfoMgr::_spInst = nullptr; //初始化为空
InfoMgr::CGarbo Garbo;//初始化

懒汉模式的特点:

  • 构造函数私有

  • 提供一个静态的方法返回单例,第一次调用创建对象,后续调用直接返回

  • 声明一个静态的单例成员指针,指针初始化为空

  • 拷贝构造和赋值声明为delete函数

  • 保证线程安全(修改指针),双检查提高效率

    懒汉模式的优缺点:

  • 优点:延迟加载,启动快。可以指定多个单例对象的初始化顺序。

  • 缺点:实现复杂一点。

2.饿汉模式和懒汉模式区别

  1. 懒汉模式需要考虑线程安全和释放的问题,实现相对复杂;饿汉模式不存在这个问题,实现起来简单。
  2. 懒汉模式是一种懒加载模式,需要时再初始化创建对象,不会影响程序的启动。饿汉模式则相反,程序启动阶段就初始化实例对象,会导致程序启动慢,影响体验。
  3. 如果有多个单例类,假设有依赖关系(B依赖A),要求A单例先创建初始化,B单例再创建初始化,就不能用饿汉模式,因为无法保证初始化顺序。
  4. 实际中懒汉模式还是更实用一些。

你可能感兴趣的:(#,C++初阶和进阶,c++,单例模式,java)