【C++】一些特殊类的实现

---

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

//法一
class HeapOnly
{
public:
	//2. 创建对象，提供接口
	//如何创建对象？写一个接口创建对象，但调用该函数需要对象，对象需要调用该函数才创建，
	//所以可以将该函数变成静态成员函数。
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}

private:
	//1. 将构造函数私有化
	HeapOnly()
	{
		//……
	}

	//3. 防止拷贝
	HeapOnly(const HeapOnly& ho) = delete;//告诉编译器删除该函数
	HeapOnly& operator=(const HeapOnly& ho) = delete;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//法二
class HeapOnly
{
public:

	//2. 写一个函数释放资源
	//为什么用写一个函数释放空间？HeapOnly hp1在程序结束后会调用析构函数，但析构函数已私有，
	//所以hp1创建失败；HeapOnly* hp2在程序结束后不会调用析构函数，所以得自己写一个函数手动
	//释放资源。
	void Destroy()
	{
		//delete ……
	}
private:
	//1. 将析构函数私有化
	~HeapOnly()
	{
		//……
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

class StackOnly
{
public:
	//2. 提供接口，返回对象
	static StackOnly CreateObj()
	{
		StackOnly so;
		return so;
	}

	//3. new = operator new + 构造（或者拷贝构造）。还有可能在堆上创建空间，
	//StackOnly* so2 = new StackOnly(so1)，但我们不能将拷贝构造私有且封掉，
	//因为上面函数是传值返回，会调用拷贝构造，所以得实现一个类专属的operator
	//new，然后私有再封掉，这样就不会在堆上创建空间
private:
	//1. 将构造函数私有
	StackOnly()
	{
		//……
	}

	//3. 私有operator new
	void* operator new(size_t size) = delete;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3. 请设计一个类，该类不能发生拷贝

class CopyBin
{
public:
private:
	CopyBin(const CopyBin& cb) = delete;
	CopyBin& operator=(const CopyBin& cd) = delete;
};
1
2
3
4
5
6
7

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

//法一：+final
class NoInherit final
{
public:
private:
};
1
2
3
4
5
6

//法二：
class NoInherit
{
public:
private:
	//将构造函数私有。子类对象构造必须调用父类的构造，不能调用就无法继承
	NoInherit()
	{
		//……
	}
};
1
2
3
4
5
6
7
8
9
10
11

5. 单例模式

//请设计一个类，该类只能创建一个对象(即：单例模式(重要))
//a.什么是单例模式？一个类只能创建一个对象
//b.模拟实现饿汉模式，并给出其优缺点
namespace hungry
{
	class OnlyOne
	{
	public:
		//2. 提供获得单例对象的成员函数
		static OnlyOne& GetInstance()
		{
			return _ins;
		}

	private:
		//1. 构造函数私有
		OnlyOne()
		{
			//……
		}

		//3. 防拷贝
		OnlyOne(const OnlyOne& oo) = delete;
		OnlyOne operator=(const OnlyOne& oo) = delete;

		static OnlyOne _ins;
	};
	OnlyOne OnlyOne::_ins;
	//优点：实现简单
	//缺点：1.如果单例对象初始化内容多，会影响启动速度。（main是启动入口，启动之前要做准备，还要创建单例对象）
	//2.如果有多个单例对象，启动顺序不确定。
}

//c.模拟实现懒汉模式，并给出其优缺点
namespace lazy
{
	class OnlyOne
	{
	public:
		//2. 提供获得单例对象的成员函数
		static OnlyOne& GetInstance()
		{
			if (_ins == nullptr)
			{
				_ins = new OnlyOne;
			}
			return *_ins;
		}

		//4. 一般单例不用释放，单例一般进程结束就结束，让编译器自动回收就行
		//特殊场景：1、中途需要显示释放  2、程序结束时，需要做一些特殊动作（如持久化）
		static void DelInstance()
		{
			if (_ins)
			{
				delete _ins;//会调用析构函数
			}
		}

		//5. 如何在程序结束后也调用析构函数？
		//写一个类，将DelInstance交给GC管理，当程序结束，GC生命周期结束，编译器会调用其析构，
		//此时就顺便将DelInstance执行
		static class GC
		{
		public:
			~GC()
			{
				DelInstance();
			}
		};

	private:
		//1. 构造函数私有
		OnlyOne()
		{
			//……
		}

		//delete会调用析构函数，由于是在类内部，所以能调用；程序结束不会调用析构函数，因为析构函数私有，
		//所以在析构函数中所做的一些事情就不能实现，所以需要显示释放
		~OnlyOne()
		{
			//……
		}

		//3. 防拷贝
		OnlyOne(const OnlyOne& oo) = delete;
		OnlyOne operator=(const OnlyOne& oo) = delete;

		static OnlyOne* _ins;
		static GC _gc;
	};
	OnlyOne* OnlyOne::_ins = nullptr;
	OnlyOne::GC OnlyOne::_gc;
	//优点：1.第一次调用GetInstance才创建对象，不会影响启动速度
	//2.不用担心启动顺序，想让谁创建单例子就让谁GetInstance。
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97