特殊类的设计

正文开始前给大家推荐个网站，前些天发现了一个巨牛的 人工智能学习网站， 通俗易懂，风趣幽默，忍不住分享一下给大家。 点击跳转到网站。

设计一个不能被拷贝的类

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

C++98中可以将拷贝构造和赋值重载私有化即可。

class copyban
{
public:
	//...
private:
	copyban(const copyban& c);
	copyban& operator+(const copyban& c);
	//...
};

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11中可以直接把拷贝构造和赋值重载禁止生成。

class copyban
{
public:
	//...
	copyban(const copyban& c) = delete;
	copyban& operator+(const copyban& c) = delete;
private:
	
	//...
};

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

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

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

	// C++98
	// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	// 2.声明成私有
	HeapOnly(const HeapOnly&);
	// or
	// C++11
	HeapOnly(const HeapOnly&) = delete;
};

也可以将析构函数给私有化，拷贝构造仍然需要禁用。

class HeapOnly
{
public:
	HeapOnly() {};
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
	static void Del(HeapOnly* del)
	{
		delete del;
	}
private:
	~HeapOnly();
	// C++98
	// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	// 2.声明成私有
	HeapOnly(const HeapOnly&);
	// or
	// C++11
	HeapOnly(const HeapOnly&) = delete;
};

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

同上将构造函数私有化，然后设计静态方法创建对象返回即可。但是别人可能用这个对象来在堆上new一个对象，但是拷贝构造不能禁用，不然静态方法没法返回，所以需要把operator new禁用一下。

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
	// 禁掉operator new可以把用new 调用拷贝构造申请对象给禁掉
	void* operator new(size_t size) = delete;
private:
	StackOnly()
		:_a(0)
	{}
private:
	int _a;
};

不能被继承的类

1. 构造函数私有化，派生类中调不到基类的构造函数。则无法继承。
2. final关键字，final修饰类，表示该类不能被继承。

设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单例模式
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

单例模式有两种实现模式：
饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
首先整个程序中只能有一个对象，我们一定是要将构造函数给私有化的，不然用户就可以在外面随便创建对象，但是唯一的一个对象要在程序启动的时候就已经创建了，只有全局对象在程序启动时就已经创建好了，所以我们这个对象一定是要在全局创建的，但是因为构造函数私有了，所以这个对象在全局也是没法创建的，所以我们可以考虑创建一个静态创建成员变量，因为每个对象的成员不包括静态成员变量，所以不存在自己包含自己的问题。静态成员变量相当于有了类域的全局变量。

//饿汉模式
class singleton
{
public:
	static singleton* GetInstance()
	{
		return &_s;
	}
private:
	//构造函数私有
	singleton() {};

	//还需要仿拷贝
	singleton(const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;

	//全局唯一的一个对象
	static singleton _s;
	//需要的成员
	//..
};

//在程序运行前就初始化了
singleton singleton::_s;

优点：简单
缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定
如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

懒汉模式
懒汉模式是你什么时候用这个对象什么时候创建，不需要程序开始时就一定创建好。
懒汉的实现和饿汉相似，只不过把静态成员变量定义成指针就好了。

//懒汉模式
class singleton
{
public:
	static singleton* GetInstance()
	{
		if (_s == nullptr)
		{
			return new singleton();
		}
		
		return _s;
	}
private:
	//构造函数私有
	singleton() {};

	//还需要仿拷贝
	singleton(const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;

	//全局唯一的一个对象
	static singleton* _s;
	//需要的成员
	//..
};

//在程序运行前就初始化了
singleton* singleton::_s = nullptr;

懒汉是不需要我们自己手动释放资源的，因为当需要释放的时候，该进程一般就要结束了，系统会自己释放的。但是有一些情况时需要我们自己提前释放的，我们提供以个释放的函数就行了，在提供一个内部类进行释放就可以了。

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

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。