特殊类设计

不能被拷贝的类

• C++98

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

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

私有是为了防止用户在类外自己定义。

• C++11

class CopyBan
{
	// ...
	CopyBan(const CopyBan&)=delete;
	CopyBan& operator=(const CopyBan&)=delete;
	//...
};

不能被继承的类

• C++ 98

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

• C++ 11

final修饰

class A final
{
	// ....
};

只能在栈上创建对象的类

构造函数私有化 + 删除operator new

class OnlyStack
{
public:
	static OnlyStack Create(int a = 2, int* ptr = new int(55))
	{
		return OnlyStack();
	}

	~OnlyStack()
	{
		cout << "~OnlyStack()" << endl;
		delete _ptr;
	}

	//static void* operator new(size_t size) = delete;    防止在堆上创建对象

private:
	OnlyStack(int a = 2, int* ptr = nullptr)
		: _a(a)
		, _ptr(ptr)
	{
		if (_ptr == nullptr)
		{
			_ptr = new int(55);
		}
	}

	int _a;
	int* _ptr;
};

只能在堆上创建对象的类

1. 析构函数私有化，通过调用函数销毁对象

class OnlyHeap
{
public:
	OnlyHeap(int a = 2, int* ptr = nullptr)
		: _a(a)
		, _ptr(ptr)
	{
		if (_ptr == nullptr)
		{
			_ptr = new int(55);
		}
	}

	void Destroy()
	{
		cout << "Destroy() : delete _ptr" << endl;
		delete _ptr;
	}

private:
	~OnlyHeap()
	{
		cout << "~OnlyHeap()" << endl;
	}

	int _a;
	int* _ptr;
};

2. 构造函数私有化 + 防拷贝

class OnlyHeap
{
public:
	static OnlyHeap* Create(int a = 2, int* ptr = new int(55))
	{
		OnlyHeap* temp = new OnlyHeap({ a, ptr });
		return temp;
	}

	~OnlyHeap()
	{
		cout << "~OnlyHeap()" << endl;
		delete _ptr;
	}
	

private:
	OnlyHeap(const OnlyHeap& temp) = delete;
	OnlyHeap& operator=(const OnlyHeap& temp) = delete;

	OnlyHeap(int a = 2, int* ptr = nullptr)
		: _a(a)
		, _ptr(ptr)
	{
		if (_ptr == nullptr)
		{
			_ptr = new int(55);
		}
	}

	int _a;
	int* _ptr;
};

单例模式

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

饿汉模式

在程序启动前创建好对象

class Single
{
	static Single* GetInstance()
	{
		return &s;
	}

private:
	Single();

	Single(const Single& temp) = delete;
	Single& operator=(const Single& temp) = delete;

	int _a;
	static Single s;
};

Single Single::s;

懒汉模式

第一次使用时创建对象

class Single
{
public:
	static Single* GetInstance()
	{
		if (nullptr == s)
			s = new Single();
		return s;
	}
private:
	Single();

	Single(const Single& temp) = delete;
	Single& operator=(const Single& temp) = delete;

	int _a;
	static Single* s;
};

Single* Single::s = nullptr;