【C++高阶(八)】单例模式&特殊类的设计

03-09 1966阅读

💓博主CSDN主页:杭电码农-NEO💓

⏩专栏分类:C++从入门到精通⏪

🚚代码仓库:NEO的学习日记🚚

🌹关注我🫵带你学习C++

  🔝🔝


【C++高阶(八)】单例模式&特殊类的设计

单例模式

  • 1. 前言
  • 2. 设计一个不能被拷贝/继承的类
  • 3. 只能在堆上创建对象的类
  • 4. 只能在栈上创建对象的类
  • 5. 只能实例化一个对象的类的介绍
  • 6. 饿汉模式的具体实现
  • 7. 懒汉模式的具体实现
  • 8. 总结以及拓展

    1. 前言

    在实际场景中,总会遇见一些特殊情况,

    比如设计一个类,只能在堆上开辟空间,

    亦或者是设计一个类只能实例化一个对象

    在实际需求的场景下,来学习这节实用课

    本章重点:

    本篇文章着重讲解如何设计一些特殊

    的类,包括不能被拷贝,只能在栈/堆上

    创建对象以及此类只能实例化一个对象,

    这也就是题目中的单例模式,单例模式又

    包含饿汉和懒汉模式,文章都是干货

    请同学们耐心学习!


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

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

    C++11中引入的关键字delete

    就能很好的解决这个问题,并且

    不仅仅要禁用拷贝,还有赋值!

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

    在C+98中,也有方法能够解决,

    那就是显示将拷贝构造函数和

    赋值运算符重载函数私有化!

    class CopyBan
    {
    private:
        CopyBan(const CopyBan&);
        CopyBan& operator=(const CopyBan&);
    };
    
    1. 设计一个不能被继承的类

    使用关键字final就能解决问题

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

    在C++98中,将构造函数私有化也能

    达到目的,因为子类的构造会调用基类

    的构造,如果私有了基类的构造就会报错!

    class NonInherit
    {
    private:
    	NonInherit()
    	{}
    };
    

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

    只能在堆上创建对象的含义就是

    必须使用new来创建对象.

    本篇文章是实用性的,就直接讲方法了:

    1. 将析构函数私有化

    将析构函数私有化后,由于对象析构时并不能调用到析构函数,所以不管是在堆上还是栈上创建对象都会报错!但是我们可以特殊处理,在共有域定义一个函数,此函数显示调用析构!

    //思路一,封析构函数
    class HeapOnly
    {
    public:
    	void destory()
    	{
    		delete this;
    	}
    private:
    	~HeapOnly()
    	{
    		cout
    public:
    	static HeapOnly* CreateObject(int x = 0)
    	{
    		return new HeapOnly(x);
    	}
    private:
    	HeapOnly(int x = 0):_x(x)
    	{}
    	int _x;
    };
    
    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;
    };
    
    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;
    
    public:
    	static Singleton* GetInstance()
    	{
    		if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁
    		{
    			imtx.lock();
    			if (_ins == nullptr)//第一次调用才创建实例!
    			{
    				_ins = new Singleton;
    			}
    			imtx.unlock();
    		}
    		
    		return _ins;
    	}
    	void DelInstance()
    	{
    		imtx.lock();
    		if (_ins != nullptr)
    		{
    			cout }
    private:
    	static Singleton* _ins;
    	static mutex imtx;
    };
    Singleton* Singleton::_ins = nullptr;
    mutex Singleton::imtx;
    
VPS购买请点击我

文章版权声明:除非注明,否则均为主机测评原创文章,转载或复制请以超链接形式并注明出处。

目录[+]