【C++】学习笔记——特殊类的设计

---

二十二、特殊类的设计

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

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

C++98：

#include <iostream>
using namespace std;

class myClass
{
	// 私有化
	myClass(const myClass& myc);
	myClass& operator=(const myClass& myc);
public:
	myClass()
	{}

	~myClass()
	{}
private:
	int _a;
};

int main()
{
	myClass my1;
	myClass my2(my1);
	my2 = my1;
	return 0;
}

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
C++11：

#include <iostream>
using namespace std;

class myClass
{
public:
	myClass()
	{}

	~myClass()
	{}

	myClass(const myClass& myc) = delete;
	myClass& operator=(const myClass& myc) = delete;
private:
	int _a;
};

int main()
{
	myClass my1;
	myClass my2(my1);
	my2 = my1;
	return 0;
}

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

实现方式：将类的构造函数私有，拷贝构造声明成私有（或delete）。防止别人调用拷贝在栈上生成对象。再提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

#include <iostream>
using namespace std;

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

	HeapOnly(const HeapOnly&) = delete;
private:
	HeapOnly()
	{}
	//HeapOnly(const HeapOnly&);
};

int main()
{
	HeapOnly h;
	HeapOnly* hp = HeapOnly::CreateObject();

	return 0;
}

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

同上将构造函数私有化（或delete），然后设计静态方法创建对象返回即可。为了防止使用new来创建堆对象，我们需要手动在类内声明operator new函数，并将其delete掉。

#include <iostream>
using namespace std;

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

	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	StackOnly()
		:_a(0)
	{}
private:
	int _a;
};

int main()
{
	StackOnly s;
	StackOnly* sp = new StackOnly;
	StackOnly s2 = StackOnly::CreateObj();

	return 0;
}

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

①将构造函数私有化，派生类中调不到基类的构造函数。则无法继承。
②C++11新关键字 final 修饰的类不能再被继承。

#include <iostream>
using namespace std;

// C++98
class NonInherit
{
public:
private:
	NonInherit()
	{}
};

class A : public NonInherit
{
public:
	A()
	{}
private:
};

// C++11
class B final
{
public:
	B()
	{}
private:
};

class C : public B
{

};

int main()
{
	return 0;
}

5. 请设计一个类，只能创建一个对象(单例模式)

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

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}

	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;
private:
	// 构造函数私有
	Singleton()
	{}
	
	// 静态对象--存在静态区，不在对象内
	static Singleton m_instance;
};

// 程序开始时就完成对单例对象的初始化
Singleton Singleton::m_instance;

由于饿汉模式在程序进入主函数前就需要把对象创建出来，如果单例模式太多，或者这个对象太大，则会拖慢程序的启动，对性能要求较高。或者要求对对象的创建顺序有要求，都不适合饿汉模式。
懒汉模式：第一次使用实例对象时，才创建对象。
我们需要判断是否是第一次使用实例，如果是第一次使用实例才创建对象，否则返回原本就存在的对象。

#include <iostream>
using namespace std;

class Singleton
{
public:
	// 创建对象
	static Singleton* GetInstance()
	{
		// 只有第一次调用时，才创建对象
		if (_psint == nullptr)
		{
			// C++98
			_psint = new Singleton;
			return _psint
			
			// C++11
			// static Singleton _psint;
			// return &_psint;
		}

		return _psint;
	}

	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;

private:
	Singleton()
	{}

	// 对象指针
	static Singleton* _psint;
};

// 初始化
Singleton* Singleton::_psint = nullptr;

---

未完待续