当前位置：首页 > article >正文

C++特殊类设计（不能被拷贝的类、只能在堆上创建对象的类、不能被继承的类、单例模式）

article 2024/11/25 3:15:55

C++特殊类设计

在实际应用中，可能需要设计一些特殊的类对象，如不能被拷贝的类、只能在堆上创建对象的类、只能在栈上创建对象的类、不能被继承的类、只能创建一个对象的类（单例模式）。

1. 不能被拷贝的类

拷贝只会发生在两个场景中：拷贝构造函数和赋值运算符重载。因此，让一个类禁止被拷贝，只需要让其拷贝构造函数和赋值运算符重载不能被调用即可。

1.1 c++98做法

c++98通过将拷贝构造函数和赋值运算符重载只声明不定义，并将其访问权限设置为私有实现禁止被拷贝。

class CopyBan
{
private:
	CopyBan(const CopyBan& cb);
	CopyBan& operator=(const CopyBan & cb);
};

1.2 现代做法

使用c++11提供的delete关键字“删除”拷贝构造函数和赋值运算符重载。

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

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

2.1 直接法

要使一个类只能在堆上创建对象，思路是：

将类的构造函数和拷贝构造函数私有，防止别人调用拷贝在栈上生成对象。
再提供一个静态成员函数，在该静态成员函数内部完成堆对象的创建。

class HeapOnly
{
	static HeapOnly* Create()//静态解决“先有函数还是现有对象问题”
	{
		return new HeapOnly;
	}
private:
	HeapOnly(){}
};

但此不能完全封死在栈上创建对象，如果通过 Create()函数先创建一个堆上的对象，再使用默认拷贝构造拷贝堆上的对象，就能够实现在栈上创建对象。

HeapOnly* ho1 = HeapOnly::Create();
HeapOnly* ho2(ho1);

所以最后还需要封死通过拷贝构造创建栈上对象：

c++98：private:HeapOnly& HeapOnly(const HeapOnly& ho){}

c++11：HeapOnly& HeapOnly(const HeapOnly& ho)=delete;

2.2 私有析构函数法

设计不能被拷贝的类还有一种方法，通过私有化析构函数，让栈上对象无法在离开作用域时自动调用析构函数，因此在栈上的创建对象的代码都不能被编译通过。再设计一个 release()函数手动释放堆上的对象。

class HeapOnly
{
public:
	static HeapOnly* Create()
	{
		return new HeapOnly;
	}
	void relase()
	{
		delete this;
	}
private:
	~HeapOnly(){}
};

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

要使一个类只能在栈上创建对象，思路是：

私有化构造函数
设计静态函数返回对象

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

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

private:
	StackOnly():_a(0){}
	int _a;
};

设计只能在栈上创建对象的类还要注意将new和delete删除，避免使用new通过拷贝构造创建堆上对象。且由于 Create()函数被设计成传值返回，不能直接通过删除拷贝构造实现（因为临时对象）。

删除new和delete的原理是，编译器默认生成一个new和一个delete，现将重载new和delete在类中重载，那么类对象会调用重载的new和重载的delete（重载后不再默认生成），但由于重载的new和重载的delete被删除，类对象在创建时便无法使用。

StackOnly so1 = StackOnly::Create();
StackOnly* so2 = new StackOnly(so1);

4. 不能被继承的类

要使一个类不能被继承，方法是：

c++98：基类析构函数私有，派生类不能调用基类的构造函数，无法编译通过
c++11：使用final关键字标记基类，表示该类不能被继承

5. 单例模式

单例模式要求一个类只能创建一个对象，该模式可以抱枕系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

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

饿汉模式
懒汉模式

5.1 饿汉模式

饿汉形容程序对对象的需要比较紧迫，不管将来用不用，在程序启动时就马上先创建一个唯一的实例对象（一般在main函数之前创建）。

#include<iostream>
using namespace std;

class ehan
{
public:
	static ehan* GetInstance()
	{
		return &_e;
	}
	int SetInfo(int info)
	{
		_info = info;
		return _info;
	}
	ehan(const ehan& e) = delete;
	ehan& operator=(const ehan& e) = delete;
private:
	ehan(){}
	int _info;
	static ehan _e;//声明
};

ehan ehan::_e;//定义
int main()
{
	cout<<ehan::GetInstance()->SetInfo(1);
	return 0;
}

优先：简单

缺点：可能会导致进程启动慢，且如果有多个单例类使用饿汉模式，它们的对象实例启动顺序不确定

5.2 懒汉模式

懒汉模式可以完美解决饿汉模式的缺点，懒汉模式一般在第一次调用 GetInstance() 的时候创建单例对象。

#include<iostream>
using namespace std;

class lanhan
{
public:
	static lanhan* GetInstance()
	{
		static lanhan _lh;
		return &_lh;
	}
	int SetInfo(int info)
	{
		_info = info;
		return _info;
	}
	lanhan(const lanhan& e) = delete;
	lanhan& operator=(const lanhan& e) = delete;
private:
	lanhan(){}
	int _info;
};

int main()
{
	cout<<lanhan::GetInstance()->SetInfo(1);
	return 0;
}

这里在 GetInstance()里定义了一个局部静态对象 static lanhan _lh; ，即使调用多次 GetInstance()，这个创建对象的代码也只会执行一次，但这种使用方法是c++11之后支持，且有线程安全风险。

传统且线程安全方法：

#include<iostream>
#include<mutex>
using namespace std;

class lanhan
{
public:
	static lanhan* GetInstance()
	{
		if (_lh == nullptr)//双重检查保证线程安全
		{
			unique_lock<mutex> lock(_mtx);
			if (_lh == nullptr)
			{
				_lh = new lanhan;
			}
		}
		return _lh;
	}
	int SetInfo(int info)
	{
		_info = info;
		return _info;
	}
	lanhan(const lanhan& e) = delete;
	lanhan& operator=(const lanhan& e) = delete;
private:
	lanhan(){}
	int _info;
	static mutex _mtx;
	static lanhan* _lh;


};
lanhan* lanhan::_lh = nullptr;
mutex lanhan::_mtx;

int main()
{
	cout<<lanhan::GetInstance()->SetInfo(1);
	return 0;
}