【小梦C嘎嘎——启航篇】C++特殊类设计

【小梦C嘎嘎——启航篇】C++特殊类设计😎

• 前言🙌
• • 1.请设计一个类，该类不能被继承
  • 2.请设计一个类，只能在堆上创建对象
  • 3.请设计一个类，只能在栈上创建对象
  • 4.请设计一个类，该类不能发生拷贝
  • 5.请设计一个类，该类只能创建一个对象
  • • 什么是单例模式
    • 饿汉模式
    • 懒汉模式的实现
    • 总结撒花💞

      

         

      😎博客昵称：博客小梦

      😊最喜欢的座右铭：全神贯注的上吧！！！

      😊作者简介：一名热爱C/C++，算法等技术、喜爱运动、热爱K歌、敢于追梦的小博主！

      😘博主小留言：哈喽！😄各位CSDN的uu们，我是你的博客好友小梦，希望我的文章可以给您带来一定的帮助，话不多说，文章推上！欢迎大家在评论区唠嗑指正，觉得好的话别忘了一键三连哦！😘

      

      前言🙌

          哈喽各位友友们😊，我今天又学到了很多有趣的知识，现在迫不及待的想和大家分享一下！😘都是精华内容，可不要错过哟！！！😍😍😍

      1.请设计一个类，该类不能被继承

      实现思想：

      • 将构造函数和拷贝构造函数私有化
      • 用C++11关键字final修饰类，表示这个类不能被继承

        class B {
        private:
        	B() {};
        	B(const B& b) = delete;
        };
        class B final{
        };
        class C :public B{
        public:
        	
        	C()
        	{}
        };
        int main()
        {
        	C c1;
        }
        

        2.请设计一个类，只能在堆上创建对象

        实现思路：

        方案一：构造函数私有化，防拷贝。通过公共接口创建堆上的对象

        class HeapOnly
        {
        public:
        	static HeapOnly* CreateObj()
        	{
        		return new HeapOnly;
        	}
        	HeapOnly(const HeapOnly& hp) = delete;
        private:
        	HeapOnly()
        	{
        		cout 
        public:
        	void Destroy()
        	{
        		delete this;
        	}
        private:
        	
        	~HeapOnly()
        	{
        		cout 
        	//HeapOnly h1;
        	HeapOnly *h1 = new HeapOnly();
        	h1-Destroy();
        	return 0;
        }
        
        public:
        	static StackOnly CreateObj()
        	{
        		StackOnly obj1;
        		return obj1;
        	}
        	//将new禁掉
        	void* operator new(size_t size) = delete;
        private:
        	// 构造函数私有化
        	StackOnly()
        	{
        		cout 
        	StackOnly s1 = StackOnly::CreateObj();
        	return 0;
        }
        
        private:
        	A(const A& a1);
        	A& operator=(const A& a1);
        };
        //c++11 实现
        class A {
        	A(const A& a1) = delete;
        	A& operator=(const A& a1) = delete;
        };
        
        public:
        	//被访问的公共节点
        	static  singletion* GetInstance()
        	{
        		return &m_instance;
        	}
        	
        	int& get_a()
        	{
        		return _a;
        	}
        	void Print()
        	{
        		cout 
        public:
        	static B* GetInstance()
        	{
        		if (_inst == nullptr)
        		{
        			_inst = new B;
        		}
        		return _inst;
        	}
        	//手动释放---直接外面调用该接口
        	static void DelInstance()
        	{
        		if (_inst)
        		{
        			delete _inst;
        			_inst = nullptr;
        		}
        	}
        private:
        	B()
        	{}
        	~B()
        	{
        		// 持久化：要求把数据写到文件
        		cout 
        	public:
        		//通过内部类的析构函数调用B类的析构接口
        		~gc()
        		{
        			DelInstance();
        		}
        	};
        	static gc _gc;
        };
        B* B::_inst = nullptr;
        //全局只有一个gc对象，刚好对应释放一次B对象的资源空间，
        //当main函数结束，gc也会结束，从而自动回收单例对象的资源
        B::gc B::_gc;