[c++进阶(三)]单例模式及特殊类的设计

1.前言

在实际场景中,总会遇见一些特殊情况,比如设计一个类,只能在堆上开辟空间,

或者是设计一个类只能实例化一个对象。那么我们应该如何编写代码呢?本篇将会详细的介绍

本章重点:

本篇文章着重讲解如何设计一些特殊
的类,包括不能被拷贝,只能在栈/堆上
创建对象以及此类只能实例化一个对象,
这也是我们听说过的单例模式,单例模式又
包含饿汉和懒汉模式,文章都是干货
请同学们耐心学习!

2.设计一个不能被拷贝/继承的类

1.设计一个类,不能被拷贝

在设计这个类之前,需要明确的是:拷贝只会放生在两个场景中拷贝构造函数以及赋值运算符重载,因此**想要让一个类禁止拷贝,**只需让该类不能调用拷贝构造函数以及赋值运算符重载即可

在c++98中一般操作就是在私有中把这两个函数只声明,不定义。

cpp 复制代码
class CopyBan
{
    
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
};

原因:
1. 设置成私有:如果只声明没有设置成private,用户自己如果在类外定义了,就可以不
能禁止拷贝了
2. 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写
反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。
C++11扩展 delete 的用法, delete 除了释放 new申请的资源外,如果在默认成员函数后跟上
=delete,表示让编译器删除掉该默认成员函数。

cpp 复制代码
class CopyBan
{
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
};

2.设计一个不能被继承的类

c++11中可以直接使用关键字final

cpp 复制代码
class A  final
{
    // ....
};

c++98:基类的构造函数私有化,这样子类在创建对象时,属于基类的那一部分会调用基类的构造函数初始化,那么由于基类的构造函数私有化了,因此无法初始化,直接报错。

cpp 复制代码
class NonInherit
{
private:
	NonInherit()
	{}
};

3.设计只能在堆上创建对象的类

只能在堆上创建对象,那么就表明所有创建的对象经过的构造函数都要用new来构造,这样才能够满足要求。

除此之外还要禁止拷贝构造和赋值函数,因为这样可以防止别人调用拷贝或者赋值重载函数来生成对象

cpp 复制代码
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;
};

解释为什么这里使用的是static:

将构造函数设置为私有后,不管是在堆上还是栈上都不能创建对象,但是我们可以在共有域写一个函数显示去调用构造函数,注意,这里的共有域函数必须设置为static类型,因为必须有了对象后才能调用函数,但是要调用了此函数才能创建对象,就会出现先有鸡还是先有蛋的问题,所以设置为static后,可以用类域调用!

方法二:将析构函数封掉。

先解释为什么这个方法可行。一般来说:
C++是静态绑定的语言在编译时期,所有的非虚函数调用都必须分析完成。则当对象建立在栈上面时,是由编译器分配内存空间的,调用构造函数来构造栈对象。当对象使用完后,编译器会调用析构函数来释放栈对象所占的空间。编译器管理了对象的整个生命周期(具体过程为: 通过直接移动栈顶指针,挪出适当的空间,然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法,直接调用类的构造函数 )。所以,编译器在为类对象分配栈空间时,会先检查类的析构函数的访问性(其实不光是析构函数,只要是非静态的函数,编译器都会进行检查)。如果类的析构函数是私有的,则编译器不会在栈空间上为类对象分配内存所以 析构函数私有化的类的设计可以保证只能用new命令在堆(heap)中创建对象。

cpp 复制代码
//封析构函数
class HeapOnly
{
public:
	void destory()
	{
		delete this;
	}
private:
	~HeapOnly()
	{
		cout<<"调用析构成功!"<<endl;
	}
};

4.设计只能在栈上创建对象的类

只能在栈上创建对象的话,那么就必须把new 和delete函数给封掉。因为new这个函数创建的对象一定是在堆上的。那其他的设计思路就和上述设计只能在堆上创建对象类似了

cpp 复制代码
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}

// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
// StackOnly obj = StackOnly::CreateObj();
// StackOnly* ptr3 = new StackOnly(obj);
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	StackOnly()  
		:_a(0)
	{}
	private:
	int _a;
};

5.只能实例化一个对象的类

一个类只能实例化出一个对象,这就是大名鼎鼎的"单例模式"。

在阐述单例模式之前,我们先需要了解一下什么是设计模式。

什么是单例模式呢?

单例模式的运用是非常的广泛的,如在线程池里面等等,可以自行去搜索了解。

单例模式有两种实现的方式:1 .饿汉模式,就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象

2.懒汉模式:只有在使用的时候,才初始化出对象。

6.饿汉模式

注意,这里实现的是样例(demo)代码,在
不同的工程场景下需要大家做灵活的变换

在设计之前先明确的是:什么情况下才会只初始化出一个对象呢?不管其他在怎么做,都不会初始化其他的对象。---静态成员函数及变量。只会初始化一次。---于是单例模式就可以设计成静态函数。

cpp 复制代码
// 饿汉模式
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return _ins;
	}
private:
	//限制类外随意创建对象
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;
	Singleton()
	{}
private:
	static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton;

注意:类里面的静态成员变量只能在类中声明,定义必须在类的外面。

单例模式的饿汉模式中,程序一启动就会把_ins,也就是唯一的实例对象给初始化,

并且由于构造函数被私有了,只能调用共有的GetInstance()函数获取_ins对象,又

由于这个对象是static类型的,所以不管你调用多少次GetInstance()都获取的是同

一个对象,也就是_ins

7.懒汉模式

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

cpp 复制代码
//懒汉模式
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		if (_ins == nullptr)
		{
			_ins = new Singleton;
		}
		return _ins;
	}
	void DelInstance()
	{
		if (_ins != nullptr)
		{
			cout << "over!!!" << endl;
			delete _ins;
			_ins = nullptr;
		}
	}
private:
	//限制类外随意创建对象
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;
	Singleton()
	{}
private:
	static Singleton* _ins;

};
Singleton* Singleton::_ins = nullptr;

但是这样在多线程的情况下会有一个问题,多个线程同时进入getinstance函数,这就导致多个线程都生成了一个对象。这和我们要求的一个类只能创建一个对象时不符合的。所以说我们要对这种不是原子的操作进行加锁(原子的操作学linux和mysql时会讲到)

修改代码如下:

cpp 复制代码
//懒汉模式
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁
		{
			mtx.lock();
			if (_ins == nullptr)//第一次调用才创建实例!
			{
				_ins = new Singleton;
			}
			mtx.unlock();
		}
		
		return _ins;
	}
	void DelInstance()
	{
		mtx.lock();
		if (_ins != nullptr)
		{
			cout << "over!!!" << endl;
			delete _ins;
			_ins = nullptr;
		}
		mtx.unlock();
	}
private:
	//限制类外随意创建对象
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;
	Singleton()
	{}
private:
	static Singleton* _ins;
	static mutex mtx;
};
Singleton* Singleton::_ins = nullptr;
mutex Singleton::mtx;

8.总结与拓展

特殊类的设计和单例模式就讲到这了,只单说概念其实大家对于单例模式的强大性还是理解的不够深刻,只有在结合项目一起使用时,那么理解就会快速增加了。

拓展:单例模式只是设计模式中的一种,还有工厂模式,适配器模式等等,有想了解这些设计模式的可以自行查阅资料。

设计模式 - 概览 | C++ 全栈知识体系 (stibel.icu)

相关推荐
mghio2 小时前
Dubbo 中的集群容错
java·微服务·dubbo
咖啡教室7 小时前
java日常开发笔记和开发问题记录
java
咖啡教室7 小时前
java练习项目记录笔记
java
鱼樱前端7 小时前
maven的基础安装和使用--mac/window版本
java·后端
RainbowSea8 小时前
6. RabbitMQ 死信队列的详细操作编写
java·消息队列·rabbitmq
RainbowSea8 小时前
5. RabbitMQ 消息队列中 Exchanges(交换机) 的详细说明
java·消息队列·rabbitmq
李少兄10 小时前
Unirest:优雅的Java HTTP客户端库
java·开发语言·http
此木|西贝10 小时前
【设计模式】原型模式
java·设计模式·原型模式
可乐加.糖10 小时前
一篇关于Netty相关的梳理总结
java·后端·网络协议·netty·信息与通信