【C++】特殊类的设计

⭐️个人主页：@小羊 ⭐️所属专栏：C++ 很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

目录

• 一、特殊类的设计
• • 1、不能被拷贝的类
  • 2、只能在堆上创建对象的类
  • • [2.1 私有构造函数](#2.1 私有构造函数)
    • [2.3 私有析构函数](#2.3 私有析构函数)
  • 3、只能在栈上创建对象的类
  • • [3.1 封operator new](#3.1 封operator new)
    • [3.2 封拷贝构造](#3.2 封拷贝构造)
  • 4、不能被继承的类
  • 5、只能创建一个对象的类（单例模式）

---

一、特殊类的设计

1、不能被拷贝的类

一个类不能被拷贝的需求还是比较常见的，比如IO流、线程等。

拷贝只会发生在两个场景中：拷贝构造和赋值重载，所以想让一个类不能被拷贝，只需要让这个类的拷贝构造和赋值重载不能被调用就可。

• C++98之前的做法是：把拷贝构造和赋值重载定义为私有成员函数，并且只声明不定义。
• C++11扩展了delete的用法，在默认成员函数后面加delete，禁止生成这个默认成员函数。

//C++98之前的做法
class Copy
{
	//...
private:
	Copy(const Copy& copy);
	Copy& operator=(const Copy& copy);
};

//C++11的做法
class Copy
{
public:
	//...
	Copy(const Copy& copy) = delete;
	Copy& operator=(const Copy& copy) = delete;
};

---

2、只能在堆上创建对象的类

2.1 私有构造函数

我们通常在静态区、栈、堆这三个地方创建对象，如果要求只能在堆上创建，可以先把所有创建的路堵死，也就是把构造函数私有化，另外还需要把拷贝构造和赋值重载给delete掉，然后给堆上创建对象开一个单独的渠道来实现。

class HeapOnly
{
public:
	HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}
	
	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly& operator=(const HeapOnly& hp) = delete;

private:
	HeapOnly()
	{}
};

但是现在有个问题，要调用这个成员函数就先得有个对象，好像陷入了一个死胡同，怎么办呢？

这里要求不通过对象就能调用成员函数，很容易就能联想到静态成员函数，因为静态成员函数可以通过类名::静态成员函数的方式来调用静态成员函数。

class HeapOnly
{
public:
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}

	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly& operator=(const HeapOnly& hp) = delete;

private:
	HeapOnly()
	{}
};

int main()
{
	HeapOnly* hp = HeapOnly::CreateObj();
	delete hp;
	return 0;
}

---

2.3 私有析构函数

除了上面堵前路，也可以堵后路，也就是将析构函数私有化。

class HeapOnly
{
public:
private:
	~HeapOnly()
	{}
};

int main()
{
	HeapOnly hp1;
	static HeapOnly hp2;
	HeapOnly* hp = new HeapOnly;

	return 0;
}

为什么上面在堆上创建的对象没事呢？

关键的原因还是只有自定义类型才会自动调用析构函数 ，而hp是一个指针。

但是现在的代码还不能在类外面deletehp，因为delete要调用析构函数，那就可以考虑在类里面调用析构函数：

class HeapOnly
{
public:
	void Destroy()
	{
		delete this;
	}
private:
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}
};

int main()
{
	//HeapOnly hp1;
	//static HeapOnly hp2;
	HeapOnly* hp = new HeapOnly;
	hp->Destroy();
	return 0;
}

---

3、只能在栈上创建对象的类

3.1 封operator new

类似只能在堆上创建对象的类：

class StackOnly
{
public:
	static StackOnly CreateOnly()
	{
		return StackOnly();
	}
private:
	StackOnly()
		:_a(0)
	{}

	int _a;
};

int main()
{
	//StackOnly sk1;
	//static StackOnly sk2;
	//StackOnly* sk3 = new StackOnly;

	StackOnly sk4 = StackOnly::CreateOnly();
	return 0;
}

但是上面的代码还能通过拷贝构造的方式在堆上创建对象：

StackOnly* sk5 = new StackOnly(sk4);

我们还不能轻易的将拷贝构造给封死 ，因为我们实现的返回栈上对象的静态成员函数是传值返回，而传值返回必然会调用拷贝构造。

还可以考虑在operator new上着手，因为new在底层会调用operator new，那我们就可以考虑把它给封死，这样就不能new对象了。

C++规定，如果一个类重载了专属的operator new，那就会调用这个operator new。

void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;

但是在静态区拷贝构造对象还是可以。

static StackOnly sk5(sk4);

---

3.2 封拷贝构造

如果还是考虑封拷贝构造，而类中返回栈上对象的静态成员函数传值返回对象又需要拷贝构造，不过这个函数返回一个临时对象，那么可以考虑通过移动构造来完成，封了拷贝构造也算是显示写了拷贝构造，编译器不会默认生成移动构造，所以还需要我们自己实现一下移动构造。

class StackOnly
{
public:
	static StackOnly CreateOnly()
	{
		return StackOnly();
	}

	StackOnly(StackOnly&& sk)
	{}

	StackOnly(const StackOnly&) = delete;
private:
	StackOnly()
		:_a(0)
	{}

	int _a;
};

虽然这个方法避开拷贝构造走移动构造，明面上满足我们的需求，但还是不能完美完成任务，因为我们还可以通过move(左值)的方法来走移动构造。

StackOnly sk5(move(sk4));
static StackOnly sk6(move(sk5));

所以走移动构造也行不通，也存在隐患。

那这么看来要实现一个只能在栈上创建对象的类好像总是不能完成的完成，总体而言还是封operator new更有性价比一点，至少不能在堆上创建对象了。

---

4、不能被继承的类

C++98的方式是把构造函数私有化，因为派生类必须调用基类的构造函数来初始化基类的部分，派生类中调不到基类的构造函数，就无法继承。

class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

C++11的方法是用final关键字，被final修饰的类不能被继承。

class NonInherit final
{
	//...
};

C++98的方法要在创建对象的时候才能查到，而C++11提供的final关键字在前期就能检查到。

---

5、只能创建一个对象的类（单例模式）

| 设计模式：

设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案 。这些解决方案是久经考验的，被广大开发者反复使用，并且被证明在多种场景下都是有效的。设计模式提供了一种标准化的沟通方式，使得开发者可以用统一的语言来描述问题及其解决方案。

| 单例模式：

单例模式是一种创建型设计模式，它确保一个类只有一个实例 ，并提供一个全局访问点来获取该实例。单例模式的主要目的是保证系统中某个类只有一个实例，并且提供一个全局访问点，以避免多个实例之间的冲突和数据不一致。

要想实现一个类只能创建一个对象，可以用类似上面的做法把构造函数私有化，不允许在类外面随便创建对象，而单例模式有两种实现方法：

• 饿汉模式

什么是饿汉呢？就是一开始就要吃。也就是这个对象要提前创建好，那我们可以在类中声明一个静态的对象，在类外初始化。

可以看到在还没有进入main函数之前，对象就已经创建好了。

当然仅仅私有构造函数还不能保证不能在类外构造对象，还需要封掉拷贝构造。

//饿汉模式
class InfoMgr
{
public:
	static InfoMgr& GetInstance()
	{
		return _ins;
	}

private:
	InfoMgr(const InfoMgr&) = delete;
	InfoMgr& operator=(const InfoMgr&) = delete;
	
	InfoMgr()
	{
		cout << "InfoMgr()" << endl;
	}
private:
	string _ip = "1.94.9.200";
	int _port = 70;
	size_t _buffSize = 1024 * 1024;

	static InfoMgr _ins;
};

InfoMgr InfoMgr::_ins;

int main()
{
	InfoMgr::GetInstance();
	//InfoMgr copy(InfoMgr::GetInstance());
	return 0;
}

但是饿汉模式还有点缺陷：

1. 多个饿汉模式的单例，某个对象初始化内容较多，会导致程序启动慢
2. A和B两个饿汉，对象初始化存在依赖，要求A先初始化，B后初始化，饿汉无法保证

• 懒汉模式

懒汉是针对饿汉做出的改良模式。懒汉是想吃的时候再做，也就是要求只能在第一次创建对象的时候构造。

//懒汉模式
class InfoMgr
{
public:
	static InfoMgr& GetInstance()
	{
		if (_pins == nullptr)
		{
			_pins = new InfoMgr;
		}
		return *_pins;
	}

private:
	InfoMgr(const InfoMgr&) = delete;
	InfoMgr& operator=(const InfoMgr&) = delete;

	InfoMgr()
	{
		cout << "InfoMgr()" << endl;
	}
private:
	string _ip = "1.94.9.200";
	int _port = 70;
	size_t _buffSize = 1024 * 1024;

	static InfoMgr* _pins;
};

InfoMgr* InfoMgr::_pins = nullptr;

int main()
{
	InfoMgr::GetInstance();
	//InfoMgr copy(InfoMgr::GetInstance());
	return 0;
}

实现懒汉还有一个更加简单的方式：

//懒汉模式
class InfoMgr
{
public:
	static InfoMgr& GetInstance()
	{
		static InfoMgr ins;
		return ins;
	}
	//...

将单例定义为局部静态对象，因为局部静态对象只在其所在函数第一次被调用时创建，和我们的需求非常契合。

---

本篇文章的分享就到这里了，如果您觉得在本文有所收获，还请留下您的三连支持哦~