C++特殊类（个人笔记）

---

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

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

解决方案：将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可或者在拷贝构造和赋值运算符重载函数后面加delete

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

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

解决方案：

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

class HeapOnly    
{     
public:     
    static HeapOnly* CreateObject()  
   {      
        return new HeapOnly;    
   }
private:    
    HeapOnly() {}
    HeapOnly(const HeapOnly& ho)； 
    //HeapOnly(const HeapOnly& hq) = delete;
};

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

解决方案：将构造函数私有化，然后设计静态方法创建对象返回。

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
    
	// 禁掉operator new可以把下面用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)
	{}
private:
	int _a;
};

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

解决方案：
final关键字，final修饰类，表示该类不能被继承或者构造函数私有化

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

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

单例模式：一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个
访问它的全局访问点，该实例被所有程序模块共享
饿汉模式：就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

//单例
//饿汉模式：提前（main函数启动时）创建好对象(现吃现做)
//优点：实现简单
//缺点：1.可能导致进程启动慢
//2.如果两个单例有启动先后顺序，那么饿汉无法控制
class A
{
public:
	static A* GetInstance()
	{
		return &_inst;
	}

	void Add(const string& key, const string& value)
	{
		_dict[key] = value;
	}

	void Print()
	{
		for (auto& kv : _dict)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	A()
	{}
	
	A(const A& aa) = delete;
	A& operator=(const A& aa) = delete;

	map<string, string> _dict;
	int _n = 0;
	static A _inst;
};
A A::_inst;

懒汉模式：延迟加载，用的时候才创建

//懒汉模式:第一次用的时候再创建(现吃现做)
//new的对象一般不需要释放，进程正常结束会释放资源
//如果需要做一些动作，比如持久化，那么可以利用gc类static对象搞定
class B
{
public:
	static B* GetInstance()
	{
		if (_inst == nullptr)
		{
			_inst = new B;
		}
		return _inst;
	}

	void Add(const string& key, const string& value)
	{
		_dict[key] = value;
	}

	void Print()
	{
		for (auto& kv : _dict)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

	static void DelInstance()
	{
		if (_inst)
		{
			delete _inst;
			_inst = nullptr;
		}
	}

private:
	B()
	{}

	~B()
	{
		//持久化：要求把数据写到文件
		cout << "数据写到文件" << endl;
	}

	B(const B& bb) = delete;
	B& operator=(const B& bb) = delete;
	map<string, string> _dict;
	int _n = 0;
	static B* _inst;

	class gc
	{
	public:
		~gc()
		{
			DelInstance();
		}
	};
	static gc _gc;
};
B* B::_inst = nullptr;
B::gc B::_gc;