特殊类设计
1.请设计一个类，不能被拷贝2.请设计一个类，只能在堆上创建对象3.请设计一个类，只能在栈上创建对象4.请设计一个类，不能被继承5.请设计一个类，只能创建一个对象(单例模式）
1.请设计一个类，不能被拷贝
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan{ // ... private: CopyBan(const CopyBan&); CopyBan& operator=(const CopyBan&); //...};为什么只声明不实现呢?
因为自己不声明，库就会自动生成。因此只要自己写库就不会默认生成。
为什么声明私有呢？
如果声明为公有类外面可以实现别人就可以调用。
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
class CopyBan{ // ... CopyBan(const CopyBan&)=delete; CopyBan& operator=(const CopyBan&)=delete; //...};2.请设计一个类，只能在堆上创建对象
1.首先我们必须要把构造函数私有
如果不把构造私有分分钟钟就创建出三个对象，并且这三个对象在不同的位置栈、堆、静态区。
class HeapOnly{};int main(){HeapOnly hp1;HeapOnly* php2 = new HeapOnly;static HeapOnly hp3;return 0;}因此把构造私有
class HeapOnly{private:HeapOnly(){}};int main(){HeapOnly hp1;HeapOnly* php2 = new HeapOnly;static HeapOnly hp3;return 0;}这样类外面就调不了构造函数。外面就不随便创建对象！
但是我还是需要创建需要的对象，因此类内部写一个创建对象的成员函数
class HeapOnly{public:HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}};但是现在问题就来了，外面根本不能创建出对象，也就是说根本调不动CreteObj。
那怎么办呢？
2.提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
静态成员函数没有this指针，可以不用对象去调用，使用类域::类的成员函数调用
class HeapOnly{public:static HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}};int main(){//HeapOnly hp1;//HeapOnly* php2 = new HeapOnly;//static HeapOnly hp3;HeapOnly* php4=HeapOnly::CreateObj();return 0;}现在这个写法有没有什么地方没有考虑到？
就是不只在堆上，还可以在别的地方创建出对象，假如是栈。
int main(){HeapOnly* php4=HeapOnly::CreateObj();//hp5在栈上！HeapOnly hp5(*php4);//拷贝构造return 0;}3.防拷贝
class HeapOnly{public:static HeapOnly* CreateObj(){return new HeapOnly;}private:HeapOnly(){}HeapOnly(const HeapOnly&) = delete;//这里赋值不用delete的，自己不写编译器默认生成的是浅拷贝，对象还是在堆上};
这是一种完整方法，只能在堆上创建对象！
还有一种方法析构函数私有+拷贝构造delete！
class HeapOnly{public:HeapOnly(){}private:~HeapOnly(){}HeapOnly(const HeapOnly&) = delete;};int main(){HeapOnly hp1;return 0;}
原因在于出了作用域会调用析构函数，这里不让调用编译就报错了。
这种写法确实只可以在堆上申请对象！但是有没有什么问题？
int main(){//HeapOnly hp1;HeapOnly* php2 = new HeapOnly;return 0;}
最显然就是没有办法delete释放资源了，有没有什么办法解决一下？
在类内部写一个Destory去释放资源。
class HeapOnly{public:HeapOnly(){}void Destory(){delete this;//或者调用显示调用析构1：对象.析构 2：this->析构//this->~HeapOnly();}private:~HeapOnly(){}HeapOnly(const HeapOnly&) = delete;};int main(){HeapOnly* php2 = new HeapOnly;php2->Destory();return 0;}3.请设计一个类，只能在栈上创建对象
方法1：同上将构造函数私有化，然后设计静态方法创建对象返回
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();return 0;}还有一种方法说的禁掉new和delete。
因为new在底层调用void* operator new(size_t size)，只需要将该函数屏蔽掉即可。
注意：也要防止定位new
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}void* operator new(size_t size) = delete;void* operator delete(size_t size) = delete;//private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();StackOnly* pso = new StackOnly;//静态封不掉static StackOnly so2;return 0;}这种方法是有问题的，如果只禁用operator new、operator delete，只是不想在堆上创建对象，但是可以在除了堆上的其他地方创建对象，全局、局部、静态都可以！
如果加上也可以，但是还是要把构造给封掉，不然静态还是可以的。
方法1的代码还有没有其他问题？
有的，方法1并没有把路封死！
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}private:StackOnly(){}};int main(){StackOnly so1=StackOnly::CreateObj();static StackOnly so2 = StackOnly::CreateObj();return 0;}静态对象还可以实现
那把拷贝构造封掉试一试
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};但是这里又不行了
这里拷贝构造不行了，那我提供一个移动构造
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}StackOnly(StackOnly&&){}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};但这里又行了
这里想说的是这个类封不死！静态的确实没有很好的办法解决。
如果真的把这里封死就一种办法，把拷贝构造封死，不让用的人这样使用。
class StackOnly{public:static StackOnly CreateObj(){return StackOnly();}//StackOnly(StackOnly&&)//{}void Print() const{cout << "StackOnly::Print()" << endl;}StackOnly(const StackOnly&) = delete;private:StackOnly(){}};int main(){//不用这样使用//StackOnly so1=StackOnly::CreateObj();//static StackOnly so2 = StackOnly::CreateObj();//而是这样用//1.StackOnly::CreateObj().Print();//2.const StackOnly& so1= StackOnly::CreateObj();so1.Print();return 0;}4.请设计一个类，不能被继承
C++98方式// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承class NonInherit{public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}};子类继承父类，必须要调用父类的构造函数，如果自己没有调用显示写调用父类，编译器就会自动调用父类的构造函数，但是父类构造私有了因此就会报错。即使在子类种显示写了调用父类构造，但是因为父类构造还是私有的，还会报错。因此这个父类就不能被子类继承！
C++11方法final关键字，final修饰类，表示该类不能被继承。
class A final{ // ....};5.请设计一个类，只能创建一个对象(单例模式）
设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
设计模式有二十多种但是常见就那么几种。C++常见的就是迭代器模式、适配器模式、单例模式，今天就主要说说单例模式，有兴趣的可以在扩展了解工厂模式、观察者模式。
单例模式：
一个类只能创建一个全局的唯一对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
任何一个类都可以写成单例模式。单例模式的类的特定：全局只有一个唯一对象。
现在考虑这样一个问题，如何让一个类全局只有一个唯一对象呢？
和上面的思路是一样的。首先还是让构造私有！不然就随意创建对象了。
class InfoSingleton{public:private:InfoSingleton(){}map<string, int> _info;//...};int main(){//InfoSingleton s1;//InfoSingleton s2;//InfoSingleton s3;return 0;}其次单例一般都会提供一个GetInstance()的静态成员函数去获取全局的唯一对象。
class InfoSingleton{public:static InfoSingleton& GetInstance(){}private:InfoSingleton(){}map<string, int> _info;//...};该如何获取呢全局的唯一对象呢？
直接定义一个全局的行不行？
class InfoSingleton{public:static InfoSingleton& GetInstance(){}private:InfoSingleton(){}map<string, int> _info;//...};//类外直接定义一个全局的InfoSingleton ins;是不行的，这里调用不了构造函数！
我们先见见第一种方法
class InfoSingleton{public:static InfoSingleton& GetInstance(){//直接返回就行return _sins;}private:InfoSingleton(){}map<string, int> _info;//...private:static InfoSingleton _sins;//类中声明成静态的成员};InfoSingleton InfoSingleton::_sins;//类外定义，因为它的类里面的因此可以调用构造函数可以认为静态的成员就是全局的，生命周期也是全局的。并且在main之前就初始化了。它和定义一个全局的没有任何区别，只是属于这个类域而已。
想获取这个对象就直接使用类域::成员函数。
int main(){InfoSingleton::GetInstance();return 0;}假设这个类提供一些其他函数，我们就可以如下访问。
class InfoSingleton{public:static InfoSingleton& GetInstance(){return _sins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}}private:InfoSingleton(){}map<string, int> _info;//...private:static InfoSingleton _sins;//类中声明成静态的成员};InfoSingleton InfoSingleton::_sins;//类外定义，因为它的类里面的因此可以调用构造函数//InfoSingleton ins;int main(){//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();return 0;}
单例模式有两种实现模式：
第一种：饿汉模式就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象（也就是说一开始(main函数之前)就创建对象），上面那种写法就是饿汉模式。
但是目前现在写的这种方法有一些不好的地方。保证不了单例！
int main(){//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();//拷贝构造InfoSingleton copy = InfoSingleton::GetInstance();copy.insert("赵六", 20000);copy.Print();infos1.Print();return 0;}
现在已经产生了两个对象了。
因此这里也要禁掉拷贝构造，甚至我也不想要赋值发生！
class InfoSingleton{public:static InfoSingleton& GetInstance(){return _sins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}cout << endl;}private:InfoSingleton(){}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...private:static InfoSingleton _sins;//类中声明成静态的成员};InfoSingleton InfoSingleton::_sins;//类外定义，因为它的类里面的因此可以调用构造函数//InfoSingleton ins;int main(){//1.InfoSingleton::GetInstance().insert("张三",10000);//2.InfoSingleton& infos1 = InfoSingleton::GetInstance();infos1.insert("李四", 15000);infos1.insert("王五", 30000);infos1.Print();//拷贝构造//InfoSingleton copy = InfoSingleton::GetInstance();//copy.insert("赵六", 20000);//copy.Print();infos1.Print();return 0;}饿汉模式的优点：
简单饿汉模式的缺点：
单例对象初始化数据太多，导致启动慢（因为在main函数之前就会初始化）多个单例有初始化依赖关系，饿汉模式无法控制
因为饿汉都是全局对象，全局对象到底谁先初始化谁后初始化，主要看编译器自己。同一个文件有先后顺序,不同文件先后顺序很难自己控制！
基于这些问题，单例还有另一种模式
懒汉模式如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
不要一开始就创建，用的时候在创建！并且只在第一次的时候创建对象，其他直接返回即可。
饿汉模式 —> 静态对象
懒汉模式 —> 静态指针
class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){//第一次获取单例对象的时候创建对象if (_psins == nullptr){_psins = new InfoSingleton;}return *_psins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}cout << endl;}private:InfoSingleton(){}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...private:static InfoSingleton* _psins;};InfoSingleton* InfoSingleton::_psins=nullptr;
懒汉模式把上面的问题都给解决了
懒汉模式的优点：
对象在main函数之后才会创建，不会影响启动顺序可以主动空间创建顺序懒汉模式的缺点：
复杂接下来我们看看复杂在那些方面
目前这段代码有没有什么问题？
多个线程一起调用GetInstace()，存在线程安全的风险
有两个线程来了之后，可能都会进入到if里面，会new两次，最终_psins指向的是第二个线程new出来的对象，这就有问题了。
如何解决呢？
加锁!
注意因为GetInstace()是静态成员函数，没有this指针只能访问静态成员变量，因此锁也要是一个静态的锁！
class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){_smtx.lock();if (_psins == nullptr){_psins = new InfoSingleton;}_smtx.unlock();return *_psins;}void insert(string name, int salary){_info[name] = salary;}void Print(){for (auto& kv : _info){cout << kv.first << " : " << kv.second << endl;}cout << endl;}private:InfoSingleton(){}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...private:static InfoSingleton* _psins;static mutex _smtx;};InfoSingleton* InfoSingleton::_psins=nullptr;mutex InfoSingleton::_smtx;加锁之后就是线程安全的了，但是这样加锁有没有什么问题？
我只想保证第一次加锁解锁后面不需要加锁解锁了。但是现在每次线程进来都需要加锁解锁，但加锁解锁也是需要资源的！
能不能把锁放在if里面？
这样是不行的！可能两个线程还是都进入if里面，其他一个线程先加锁new一个对象然后解锁，但是时间片到了就切走了，另一个线程就开始加锁然后也new一个对象最后解锁，现在就是线程不安全的了！
这里真正的解决办法：双检查加锁
不仅是这里，以后只要是想保护第一次申请都可以用这种方法！
static InfoSingleton& GetInstance(){//第一次if，对象new出来之后，避免每次都加锁的检查，提高性能if (_psins == nullptr){_smtx.lock();//第二次if，保证线程安全且只能new一次if (_psins == nullptr){_psins = new InfoSingleton;}_smtx.unlock();}return *_psins;}饿汉模式没有线程安全吗？需要加锁吗？
饿汉模式没有线程安全的问题，因此不需要加锁！main函数之前没有可能存在两个线程去调用GetInstance()，在main函数之前这个单例模式的静态对象就已经初始化好了。而这个线程是自己些的并且在main函数之后才会调用的。但是对象已经创建好了因此不存在线程安全的问题。
再看这段代码，还有没有什么问题？
new可能抛异常，造成没解锁
第一次解决方法就是捕捉异常
static InfoSingleton& GetInstance(){if (_psins == nullptr){_smtx.lock();try{if (_psins == nullptr){_psins = new InfoSingleton;}}catch (...){_smtx.unlock();throw;}}return *_psins;}但是这种写法有点挫。
第二种解决方法RAII管理锁
构造时加锁，析构时解锁！
可以自己写一个RAII锁管理类
//RAII锁管理类template<class Lock>class LockGuard{public:LockGuard(Lock& mtx):_mtx(mtx)//锁不能拷贝构造,1.传锁的地址过来 2.私有成员给个引用{_mtx.lock();}~LockGuard(){_mtx.unlock();}private:Lock& _mtx;//引用的成员变量，必须在初始化列表初始化};class InfoSingleton{public://这里可以也可以返回指针static InfoSingleton& GetInstance(){if (_psins == nullptr){LockGuard<mutex> lockguard(_smtx);//_smtx.lock();if (_psins == nullptr){_psins = new InfoSingleton;}//_smtx.unlock();}return *_psins;}//。。。。};或者用库里提供的RAII风格的锁
static InfoSingleton& GetInstance(){if (_psins == nullptr){std::lock_guard<mutex> lock(_smtx);if (_psins == nullptr){_psins = new InfoSingleton;}}return *_psins;}现在这个代码还有没有可以优化的呢？
可能会想到释放的问题。
一般单例对象不需要考虑释放！单例对象在整个程序运行期间都要在都要用，所以一般不需要释放，那new了就不delete会有问题吗？其实也并没有什么问题。进程正常结束之后会清理资源。
有些地方需要考虑释放问题： 如单例对象不用时，一些资源需要保存，必须要手动处理！
就可以提供一个静态的DelInstance()
static void DelInstance(){//保存数据到文件//...std::lock_guard<mutex> lock(_smtx);if (_psins){delete _psins;_psins = nullptr;}}如果忘记调用，但是必须要把数据存到文件中呢？
可以内部再实现一个类，实现自动回收！
class InfoSingleton{public:static InfoSingleton& GetInstance(){if (_psins == nullptr){std::lock_guard<mutex> lock(_smtx);if (_psins == nullptr){_psins = new InfoSingleton;}}return *_psins;}static void DelInstance(){//保存数据到文件//...std::lock_guard<mutex> lock(_smtx);if (_psins){delete _psins;_psins = nullptr;}}class GC//内部类是外部类有元{public:~GC(){if (_psins){DelInstance();//所以这里可以直接调}}};//。。。private:static InfoSingleton* _psins;static mutex _smtx;static GC _gc;};InfoSingleton* InfoSingleton::_psins=nullptr;mutex InfoSingleton::_smtx;InfoSingleton::GC InfoSingleton::_gc;//定义一个GC类的对象,main函数结束之后会自动调用GC的析构函数这两种写法既可以手动调用主动回收，也可以让它在程序结束之后自动回收。
见识到懒汉的复杂之处了把，其实懒汉还有一种非常方便的写法。
懒汉模式二
class InfoSingleton{public://静态函数中写个该类静态对象static InfoSingleton& GetInstance(){static InfoSingleton sinst;return sinst;}//。。。private:InfoSingleton(){cout << "InfoSingleton()" << endl;}InfoSingleton(const InfoSingleton& info) = delete;InfoSingleton& operator=(const InfoSingleton& info) = delete;map<string, int> _info;//...};这种写法能不能称为懒汉？
可以的。懒汉只有在第一次调用的时候在创建对象。
现在这个局部静态对象它就是main函数之前初始化，还是在main函数之后初始化的？
局部静态是在main函数之后才会初始化，并且只会在第一次调用才会调用构造函数，第二次开始之后就不会在调用构造了，而是直接用。
所以这种写法就是懒汉模式。
但是这种写法需要注意一些问题：
是懒汉，因为静态的局部变量是在main函数之后才创建初始化的C++11之前，这里是不能保证static的初始化是线程安全的C++11之后，可以