C++特殊类设计

一、设计一个类，不能被拷贝

只有拷贝构造和赋值运算符重载才能拷贝，因此只要把拷贝和赋值重载禁掉即可，有两种方式可以实现。

C++98

将拷贝构造和赋值运算符重载设成私有成员函数。并且只声明不对其进行实现。

class Nocopy
{
public:
	//...

private:
	Nocopy(Nocopy& st);
	Nocopy& operator=(Nocopy& st);
    //...
};

C++11

C++11扩展了delete的使用方法，它不仅可以释放new出来的资源，而且在成员函数后面加上=delete表示让编译器默认函数删除该函数。

原因：

必须要把这两个成员函数设置成private，如果是公有不实现的话，如果在类外面实现了这两个函数，就还是会被拷贝。

只声明不定义是因为定义是没有意义的，因为根本不会使用这两个成员函数，而且如果定义了在类里面还是可以拷贝的。

class noCopy
{
public:
    //...
	noCopy(const noCopy& n) = delete;
	noCopy operator=(noCopy& n) = delete;
private:
	//...
};

二、设计一个类，只能在堆上构造

要使创建的类只能在堆上构造，有两种实现方式。

第一种方式是将析构函数设成私有。然后提供一个接口用来释放资源。

class heaponly
{
public:

	//...
	void Destroy()
	{
		delete this;
	}
private:
	~heaponly()
	{}
	//...

};

int main()
{
	//heaponly h1(1);
	heaponly* h2 = new heaponly;
	h2->Destroy();
	return 0;
}

原因： 所有的对象在程序结束时候都必须要掉用析构函数释放成员，如果析构私有化，将调用不了析构函数，如果类大量的申请资源，程序结束的时候释放不了，就将造成内存泄漏，因此为了避免这种情况只能在堆上构造。

第二种是将构造函数私有，然后提供一个静态成员函数来构造对象。

class heaponly
{
public:

	//...
	static heaponly* creatObj()
	{
		return new heaponly();
	}
	~heaponly()
	{}
private:
	heaponly()
	{}
	//...

};

int main()
{
	heaponly* h = heaponly::creatObj();
	return 0;
}

三、设计一个类，只能在栈上构造

方法同上：先把构造函数私有。然后提供一个静态接口创建对象即可。

class stackonly
{
public:
	static stackonly creatobj()
	{
		stackonly s1(13);
		return s1;
	}
private:
	//stackonly(stackonly& s1) = delete;
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;

	stackonly(int a = 11)
		:_a(a)
	{}
	int _a;
};

这里要注意拷贝的问题，这时不能将拷贝构造和赋值运算符删除，因为提供接口的时候需要拷贝对象的。因此只能将new和delete运算符进行operator。 

四、设计一个类，不能被继承

C++98的方式是将构造函数私有，派生类中调不了基类的构造函数，自然就继承不了。

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

C++11提供了final关键字，使用它即可。表示是最终类，不可以继承。

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

五、设计一个类，只能构造一个对象（单例模式）

设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的
总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打
仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后
来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模
式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个
访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置
信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再
通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式：

饿汉模式： 

不管你用不用对象，我一上来就创建对象。

我们先来看看如何写一个类让它只能构造一个对象。

第一步：构造函数私有：我们铁要把构造函数私有化，将它私有化就不能随便创建对象了。

第二步：提供获取单例对象的接口：私有了之后我们一定要提供一个创建对象的接口，不然怎么创建对象呢？但是我们这两步是不行的，因为提供了接口函数我还是可以创建许多个对象，怎么保证能让它只构造一个对象呢？那我们让它每一次提供的对象都是同一个对象是不是就可以了呢？可是如何保证每次都是提供的都是同一个对象呢？我们仔细一想，静态是不是就能上场了？静态成员它在类中始终只有一份，因此我们要写一个静态的私有成员对象。

第三步：防拷贝
直接将拷贝构造和赋值运算符重载=delete即可。

#include<map>
#include<iostream>
using namespace std;
//单例模式
class singleton
{
/ 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
public:
	//2、提供获取单例对象接口
	static singleton& getInstance()
	{
		return _sin;
	}

	void Add(const pair<string, string> kv)
	{
		_dict[kv.first] = kv.second;
	}
	
	void print()
	{
		for (auto& e : _dict)
		{
			cout << e.first << ":" << e.second << endl;
		}
	}
private:
	//3、防拷贝
	singleton(const singleton& st) = delete;
	singleton& operator=(singleton& st) = delete;
	//1、构造函数私有
	singleton()
	{}
	map<string, string> _dict;
	
	static singleton _sin;//这里是不会套娃的，因为它是静态的
};
singleton singleton::_sin;//程序一上来就会调用构造函数初始化它。

int main()
{
	//singleton d1 = singleton::getInstance();
	//cout << &singleton::getInstance() << endl;
	//cout << &singleton::getInstance() << endl;
	//cout << &singleton::getInstance() << endl;
	singleton::getInstance().Add(make_pair("xxx", "aaaa"));
	singleton::getInstance().Add({"mrl","6666"});
	singleton::getInstance().print();
	

	return 0;
}

为什么称它为饿汉模式捏？饿汉有什么特点，饿汉就是一上来就吃，一上来就吃会出问题的。在这里就是这个静态对象它会在还没进入main函数的时候就创建了。它一上来就创建对象会出什么问题？是不是就会让运行效率降低。如果这个类非常大，它初始化要很久，main函数在这里一直等你创建，创建完了在进入main函数，就会效率很低，就如你点开淘宝一直给你白屏，过了十几秒才好，你是不是会很急呀，并且对与写代码的人来说，这个程序半天不出结果就问你你急不急。并且如果这个类里面还有其它一些类，那就很难受了，因此就有了第二种模式叫懒汉模式。

懒汉模式：

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

那么我们如何让它一上来别创建呢？我们把它搞成一个指针不就好了吗？把它初始化为空，你用的时候如果它为空就new创建对象，不为空就直接返回指针就ok了。其它的都不用变。就完事了。

// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控
制。
// 缺点：复杂
#include<isotream>
using namespace std;
namespace lazy
{
	class singleton
	{
	public:
		//2、提供获取单例对象接口
		static singleton* getInstance()
		{
			if (_sin == nullptr)
			{
				_sin = new singleton;
			}
			return _sin;
		}

		void Add(const pair<string, string> kv)
		{
			_dict[kv.first] = kv.second;
		}

		void print()
		{
			for (auto& e : _dict)
			{
				cout << e.first << ":" << e.second << endl;
			}
		}
	private:
		//3、防拷贝
		singleton(const singleton& st) = delete;
		singleton& operator=(singleton& st) = delete;
		//1、构造函数私有
		singleton()
		{
			cout << "1111" << endl;
		}
		map<string, string> _dict;

		static singleton* _sin;
	};
	singleton* singleton::_sin = nullptr;//只需要把它搞成指针即可
}

int main()
{
	lazy::singleton::getInstance()->Add(make_pair("xxx", "aaaa"));
	lazy::singleton::getInstance()->Add({ "mrl","6666" });
	lazy::singleton::getInstance()->print();
	return 0;
}