【C++】特殊类设计

1.设计一个类，不能被拷贝

由于拷贝只会发生在拷贝构造函数和赋值重载中，所以想要让一个类禁止拷贝只需让该类不能调用以上两种函数即可。
C++98 ：

将两种函数只声明不定义，且将访问权限设置为私有即可。

cpp 复制代码

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

1.若没有设置为私有，用户可能在类外定义，无法禁止拷贝。

2.只声明不定义：该函数根本不会被调用，无需做无用功，且能防止成员函数内部拷贝。
C++11

扩展delete用法：如果在默认成员函数后面跟上=delete，表示让编译器删除掉该默认成员函数。

cpp 复制代码

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

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

复制代码

1.将类的构造函数私有，拷贝构造声明为私有。防止调用拷贝在栈上生成对象。
2.提供一个静态的成员函数，在该函数中完成堆对象的创建。

cpp 复制代码

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

	//第一种类设计的两种方式
	HeapOnly(const HeapOnly&);
	//or
	HeapOnly(const HeapOnly&) = delete;
};

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

cpp 复制代码

class StackOnly
{
public:
	static StackOnly CreatObj()
	{
		return StackOnly();
	}
	//禁掉operator new可以避免下面这种情况
	//StackOnly obj=StackOnly::CreateObj();
	//StackOnly* ptr3=new StackOnly(obj);
	void* operator new(size_t size)=delete;
	void operator delete(void* p)=delete;
private:
	StackOnly()
		:_a(0)
	{ }
	int _a;
};

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

C++98方式：

将构造函数私有化，派生类调不到基类的构造函数，则无法继承。

cpp 复制代码

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

C++11方法：

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

cpp 复制代码

class A final
{
   //...
};

设计一个类，只能创建一个对象（单例模式）

设计模式： 一套被反复使用，多数人知晓，经过分类的代码设计经验的总结。
单例模式： 即一个类只能创建一个对象。该模式保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

单例模式有两种实现形式：
饿汉模式 ：不管将来用不用，程序启动时就创建一个唯一的实例对象。

优点：简单

缺点：可能导致进程启动慢，且如果有多个单例类对象实例时启动顺序不确定。

cpp 复制代码

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
private:
	//构造函数私有
	Singleton() {};
	//C++98防拷贝
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
	//or
	//C++11
	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;

	static Singleton m_instance;
};
Singleton Singleton::m_instance;//在程序入口之前就完成单例对象的初始化。

若这个单例对象在多线程高并发环境下频繁使用，性能要求较高，所以使用饿汉模式来避免资源竞争（？），提高响应速度更好。
懒汉模式 ：延迟加载

优点：第一次使用实例对象时创建对象。进程启动无负载，多个单例实例启动顺序自由控制。

缺点：复杂。

cpp 复制代码

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		//!!!这里用double-check方式加锁，保证效率和线程安全。
		if (m_pInstance == nullptr)
		{
			m_mtx.lock();
			if (nullptr == m_pInstance)
			{
				m_pInstance = new Singleton();
			}
			m_mtx.unlock();
		}
		return m_pInstance;
	}
	//一个内嵌垃圾回收类
	class Garbo
	{
	public:
		~Garbo()
		{
			if (Singleton::m_pInstance)
				delete Singleton::m_pInstance;
		}
	};
	static Garbo sh;
	//定义一个静态成员变量，程序结束时，系统会自动调用析构函数释放单例对象。
private:
	Singleton() {};
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);

	static Singleton* m_pInstance;//单例对象指针
	static mutex m_mtx;//互斥锁
};
Singleton* Singleton::m_pInstance = nullptr;
mutex Singleton::m_mtx;
int main()
{
	thread t1([] {cout << Singleton::GetInstance() << endl; });
	thread t2([] {cout << Singleton::GetInstance() << endl; });

	t1.join();
	t2.join();

	cout << Singleton::GetInstance() << endl;
	return 0;
}

在这里插入图片描述