C++ 特殊类的设计

虾..2025-11-22 8:02

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

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，

只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

C++98

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

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

原因：

1.设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，还是可以通过调用类外面定义的函数进行拷贝。

  1. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写

反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++ 11

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上

=delete，表示让编译器删除掉该默认成员函数。

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

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

实现方式：

  1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

  2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

cpp 复制代码 
class HeapOnly
{
public:
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{
		//...
	}

	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly& operator=(const HeapOnly& hp) = delete;
};
cpp 复制代码 
int main()
{
	HeapOnly hp1;
	static HeapOnly hp2;
	HeapOnly* hp3 = new HeapOnly;
	HeapOnly* hp3 = HeapOnly::CreateObj();
	HeapOnly copy(*hp3);//阻止通过拷贝构造在栈上开辟空间

	return 0;
}

构造函数私有化有利于我们对构造函数的管理，暴露一个接口只能在堆上开辟空间，但是会引发"先有鸡还是先有蛋"的问题，调用类成员函数需要类对象，类对象的创建又需要类成员函数，所以设置为静态成员函数，静态成员函数的调用不需要类对象。

3.设计一个类只能在栈上创建对象

同上面方法差不多，构造函数私有化，设计静态函数创建对象并返回。

cpp 复制代码 
//只能在栈上创建对象
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly st;
		return st;
	}
private:
	StackOnly()
	{
		//...
	}

	// 对一个类实现专属operator new
	void* operator new(size_t size) = delete;
};

但是避免不了通过new创建一个对象如何来创造一个在堆上的对象。

cpp 复制代码 
int main()
{
	/*StackOnly hp1;
	static StackOnly hp2;
	StackOnly* hp3 = new StackOnly;*/
	StackOnly hp3 = StackOnly::CreateObj();
	StackOnly copy(hp3);

	/*  new  operator new + 构造*/
	 //StackOnly* hp4 = new StackOnly(hp3);

	return 0;
}

new是通过调用operator new和构造函数来实现的，虽然把构造函数封住了，但是可以通过调用拷贝构造来实现，我们又不能把拷贝构造给封住了，因为我们是通过调用成员函数加拷贝构造来实现类对象的创建的，所以只可以对operator new出手，把operator new封住。

4.设计一个类，不可以被继承

C++ 98

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

派生类的的基类对象需要调用基类的构造函数，把构造函数封住。

C++ 11

final关键字，final修饰类，表示该类不能被继承。

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

5. 设计一个类，只可以创建一个对象（单例模式）

设计模式：

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

总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打

仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后

来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模

式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个

访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置

信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再

通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

单例模式有两种实现模式：

5.1 饿汉模式

相对于不管你将来使用不使用，程序启动时就创建一个唯一的对象。

cpp 复制代码 
namespace hungry
{
	class Singleton
	{
	public:
		// 2、提供获取单例对象的接口函数
		static Singleton& GetInstance()
		{
			return _sinst;
		}

		void Add(const pair<string, string>& kv)
		{
			_dict[kv.first] = kv.second;
		}

		void Print()
		{
			for (auto& e : _dict)
			{
				cout << e.first << ":" << e.second << endl;
			}
			cout << endl;
		}

	private:
		// 1、构造函数私有
		Singleton()
		{
			// ...
		}

		// 3、防拷贝
		Singleton(const Singleton& s) = delete;
		Singleton& operator=(const Singleton& s) = delete;

		map<string, string> _dict;
		// ...

		static Singleton _sinst;
	};

	Singleton Singleton::_sinst;
}

原理：

1.将构造函数私有化，使得类外面不能创造

2.禁用拷贝构造函数和赋值操作符，防止复制。

3.静态类成员变量私有，防止再次创建另一个。

4.提供一个共有静态成员函数 ，引用返回唯一对象，在类外利用。

优点：

简单

缺点：

1.因为在程序启动时就创建，如果有多个单例，可能会造成程序启动缓慢。

2.如果两个单例有强耦合关系，比如单例A构造函数需要单例B，但是编译器链接顺序C++标准没有规定，就有可能造成程序崩溃。

5.2 懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取

文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，

就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

cpp 复制代码 
namespace lazy
{
	class Singleton
	{
	public:
		// 2、提供获取单例对象的接口函数
		static Singleton& GetInstance()
		{
			if (_psinst == nullptr)
			{
				// 第一次调用GetInstance的时候创建单例对象
				_psinst = new Singleton;
			}

			return *_psinst;
		}

		void Add(const pair<string, string>& kv)
		{
			_dict[kv.first] = kv.second;
		}

		void Print()
		{
			for (auto& e : _dict)
			{
				cout << e.first << ":" << e.second << endl;
			}
			cout << endl;
		}


	private:
		// 1、构造函数私有
		Singleton()
		{
			// ...
		}

		~Singleton()
		{
			cout << "~Singleton()" << endl;
		}

		// 3、防拷贝
		Singleton(const Singleton& s) = delete;
		Singleton& operator=(const Singleton& s) = delete;

		map<string, string> _dict;
		// ...

		static Singleton* _psinst;
	};

	Singleton* Singleton::_psinst = nullptr;
}

懒汉模式可以很好的解决饿汉模式的问题，在程序启动时，只创建指针，可以手动去定义不同单例的初始化顺序。

因为懒汉模式下的对象是我们new出来的，存放在堆上面，编译器并不知道我们什么时候要释放，所以我们应该手动的去释放。

cpp 复制代码 
static void DelInstance()
{
	if (_psinst)
	{
		delete _psinst;
		_psinst = nullptr;
	}
}

当我们手动释放后，编译器才会去调用析构函数。

cpp 复制代码 
namespace lazy
{
	class Singleton
	{
	public:
		// 2、提供获取单例对象的接口函数
		static Singleton& GetInstance()
		{
			if (_psinst == nullptr)
			{
				// 第一次调用GetInstance的时候创建单例对象
				_psinst = new Singleton;
			}

			return *_psinst;
		}

		void Add(const pair<string, string>& kv)
		{
			_dict[kv.first] = kv.second;
		}

		void Print()
		{
			for (auto& e : _dict)
			{
				cout << e.first << ":" << e.second << endl;
			}
			cout << endl;
		}
		static void DelInstance()
		{
			if (_psinst)
			{
				delete _psinst;
				_psinst = nullptr;
			}
		}

	private:
		// 1、构造函数私有
		Singleton()
		{
			// ...
		}

		~Singleton()
		{
			cout << "~Singleton()" << endl;
		}

		// 3、防拷贝
		Singleton(const Singleton& s) = delete;
		Singleton& operator=(const Singleton& s) = delete;

		map<string, string> _dict;
		// ...

		static Singleton* _psinst;
	};

	Singleton* Singleton::_psinst = nullptr;
}
int main()
{
	lazy::Singleton::GetInstance();
	lazy::Singleton::DelInstance();//调用析构
}

当我们需要在析构之前做一些持久化的动作，比如写入到文件中，那我们每次都去手动的调用一下DelInstance函数，如何编译器调用析构来帮助我们完成吗？

可以嵌套一个内部类在类中，在内部类的析构中去调用DelInstance函数。

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

		void Add(const pair<string, string>& kv)
		{
			_dict[kv.first] = kv.second;
		}

		void Print()
		{
			for (auto& e : _dict)
			{
				cout << e.first << ":" << e.second << endl;
			}
			cout << endl;
		}

		class GC
		{
		public:
			~GC()
			{
				lazy::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;
}

设计一个内部类，这内部类属于这个类，这个类结束的时候，这个内部类一定会调用它的析构，也就会调用DelInstance函数，就会调用析构函数，执行写入操作。

ps：这里的单例一般不需要释放原因是操作系统为了避免内存泄漏，会在进程结束后进行强制回收。

相关推荐
拾忆，想起2 小时前
Dubbo超时问题排查与调优指南：从根因到解决方案
服务器·开发语言·网络·微服务·架构·php·dubbo
7ioik3 小时前
什么是线程池？线程池的作用？线程池的四种创建方法？
java·开发语言·spring
晨非辰3 小时前
数据结构排序系列指南：从O(n²)到O(n)，计数排序如何实现线性时间复杂度
运维·数据结构·c++·人工智能·后端·深度学习·排序算法
寻星探路3 小时前
JavaSE重点总结后篇
java·开发语言·算法
Charles_go4 小时前
C#中级8、什么是缓存
开发语言·缓存·c#
残影飞雪4 小时前
Jetson版本下Pytorch和torchvision
c++
松涛和鸣5 小时前
14、C 语言进阶：函数指针、typedef、二级指针、const 指针
c语言·开发语言·算法·排序算法·学习方法
智商低情商凑9 小时前
Go学习之 - Goroutines和channels
开发语言·学习·golang
半桶水专家9 小时前
Go 语言时间处理（time 包）详解
开发语言·后端·golang
热门推荐
01GitHub 镜像站点02Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南03UV安装并设置国内源04今天 Cloudflare 全球事故，连 GPT 和你的网站都一起“掉线”了05【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连06BongoCat - 跨平台键盘猫动画工具07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Linux下V2Ray安装配置指南09全球最强模型Grok4，国内已可免费使用！（附教程）1046个Nano-banana 精选提示词，持续更新中