【C++高阶】解锁C++的深层魅力——探索特殊类的奥秘

//不能被拷贝的类
//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;
	//...
};

//只能在堆上创建对象
class HeapOnly
{
public:
	// 对象的销毁
	/*static void Destroy(HeapOnly* ptr)
	{
		delete ptr;
	}*/
	
	// 对象的销毁
	void Destroy()
	{
		delete this;
	}

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

int main()
{
	HeapOnly* ptr = new HeapOnly;

	//HeapOnly::Destroy(ptr);

	ptr->Destroy();
	return 0;
}

class HeapOnly
{
public:
	// 静态的成员函数,完成完成堆对象的创建
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}

private:
	HeapOnly()
	{
		cout << "HeapOnly()" << endl;
	}
	
	// 防止别人调用拷贝在栈上生成对象
	//C++98
	HeapOnly(const HeapOnly& copy);
	
	//C++11
	HeapOnly(const HeapOnly& copy) = delete;
};

int main()
{
	HeapOnly* ptr = HeapOnly::CreateObj();

	//HeapOnly copy(*ptr);

	return 0; 
}

static StackOnly CreateObj()
	{
		StackOnly obj;
		return obj;
	}

// 这里会让对象在堆上创建
StackOnly* ptr = new StackOnly(obj);
// 如果我们 delete 拷贝构造，会发现CreateObj()也会受到影响，所以我们只能另辟蹊径
// 我们要从 new 下手让我们不能用 new 来创建对象

void* operator new(size_t size)
{
	cout << "void* operator new(size_t size)" << endl;
	return malloc(size);
}

// 只能在栈上创建的类
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly obj;
		return obj;
	}

	// 如果我们将拷贝构造delete，那么我们就无法创建对象，因为在CreateObj()中也会发生拷贝构造
	//StackOnly(const StackOnly& copy) = delete;

	void* operator new(size_t size) = delete;

	//实现专属的operator new
	//当我们new这类对象时，我们会优先调用operator new,而不是全局(就近原则)
	/*void* operator new(size_t size)
	{
		cout << "void* operator new(size_t size)" << endl;
		return malloc(size);
	}*/

private:
	StackOnly()
	{
		cout << "StackOnly()" << endl;
	}
};

int main()
{
	StackOnly obj = StackOnly::CreateObj();

	// 发生拷贝构造是会在堆上创建类，但是我们能不能将拷贝构造delete呢？
	//StackOnly* ptr = new StackOnly(obj);

	return 0;
}

// 不能被继承的类
//C++98
class A
{
public:
	static A GetInstance()
	{
		return A();
	}
private:
	A()
	{}
};

// 不能被继承的类
//C++11
class A final
{
	// ....
};

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;
		}
	}
	
private:
	A() // 私有构造函数  
	{}

	//限制类外随意创建对象
	A(const A& copy) = delete;
	A& operator=(const A& aa) = delete;

	map<string, string> dict;

	static A _inst;// 静态实例  
	
};
// 类的外部定义静态实例  
A A::_inst;

int main()
{
	A::GetInstance()->Add("sort", "排序");
	A::GetInstance()->Add("left", "左边");
	A::GetInstance()->Add("right", "右边");
	A::GetInstance()->Print();
	
	return 0;
}

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;
		}
	}
	
	static void DelInstance()
	{
		if (_inst)
		{
			delete _inst;
			_inst = nullptr;
		}
	}
private:
	B()
	{}

	//限制类外随意创建对象
	B(const B& copy) = delete;
	B& operator=(const B& bb) = delete;

	map<string, string> _dict;

	static B* _inst; // 指针的形式

	class gc
	{
	public:
		~gc()
		{
			DelInstance();
		}
	};
	static gc _gc;
};

B* B::_inst = nullptr;
B::gc B::_gc;

int main()
{
	B::GetInstance()->Add("sort", "排序");
	B::GetInstance()->Add("left", "左边");
	B::GetInstance()->Add("right", "右边");

	B::GetInstance()->Print();
	return 0;
}