一、设计一个类，不能被拷贝
拷贝只会发生在两个场景中：拷贝构造函数和赋值运算符重载。
因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
1、C++98
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan { public: CopyBan() {} private: CopyBan(const CopyBan& cb); // 拷贝构造函数声明 CopyBan& operator=(const CopyBan& cb); // 赋值运算符重载声明 };
【原因】
- 设置成私有：如果只声明而没有设置成 private，用户自己如果在类外定义了，就可以不能禁止拷贝了。
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没什么意义，不写反而更简单，而且如果定义了就不能防止成员函数内部拷贝了。
如上图代码，在对这个特殊类进行拷贝和赋值的时候，因为这两个成员函数私有而无法调用。
拷贝构造以及赋值运算符重载等成员函数，在调用时都是编译器在域外调用，所以必须是公有的。
2、C++11
C++11 扩展了 delete 的用法，delete 除了释放 new 申请的资源以外，如果在默认成员函数后跟上 = delete，表示让编译器删除掉该默认成员函数，此时编译器也不会自动生成默认的拷贝构造和赋值运算符重载函数。
class CopyBan { public: CopyBan() {} private: CopyBan(const CopyBan& cb) = delete; // 拷贝构造函数声明 CopyBan& operator=(const CopyBan& cb) = delete; // 赋值运算符重载声明 };
二、设计一个类，只能在堆上创建对象
正常创建类对象时，会在栈上创建，并且自动调用构造函数来初始化。下面设计一个类，只能在堆上创建对象。
1、实现方式
只能在创建在堆上时，就需要让该对象只能通过 new 来创建，并且调用构造函数来初始化。
- 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
class HeapOnly { public: static HeapOnly* CreateObject() { return new HeapOnly; } private: //构造函数 HeapOnly() {} HeapOnly(const HeapOnly& hp) = delete; // 禁止拷贝 };
定义一个静态成员函数，在该函数内部 new 一个 HeapOnly 对象。将构造函数和拷贝构造函数私有，并且禁止生成拷贝构造函数。
【原因】
- 使用静态成员函数 new 一个 HeapOnly 对象。
那么非静态成员函数在调用时，必须使用点 (.) 操作符来调用，这一步是为了传 this 指针。这样的前提是先有一个 HeapOnly 对象，但是构造函数设置成了私有，就无法创建这样一个对象。
而静态成员函数的调用不用传 this 指针，也就不需要必须有 HeapOnly 对象，只需要类域 :: 静态成员函数即可。静态成员函数属于 HeapOnly 域内，所以在 new 一个对象的时候，可以调用私有的构造函数。
- 禁止调用拷贝构造函数并且私有化。
这样做的目的是为了禁止拷贝，防止使用堆区上的 HeapOnly 对象在栈区上拷贝，如下面代码：
而禁止了拷贝构造就杜绝了这一行为，从而保证了 HeapOnly 对象只能在堆上创建。
三、设计一个类，只能在栈上创建对象
- 主要是需要做到不能在堆上创建类对象。
- new 一个对象的时候，会调用该类的 operator new(size_t size) 函数，在释放资源的时候又会调用该类的 operator delete(void* p) 函数。
1、方法一
所以防止在堆上创建类对象就是要禁止调用 operator new(size_t size) 和 operator delete(void* p) 这两个函数。
class StackOnly { public: // 构造函数 StackOnly() {} void* operator new(size_t size) = delete; // 禁止调用new void operator delete(void* p) = delete; // 禁止调用delete };
使用 delete 来禁止这两个函数的调用，那么在 new 一个对象的时候，就会产生编译错误，从而无法在堆区上创建类对象。
此时在堆上创建对象时就会报错，尝试引用已删除的函数。
2、方法二
另一种方式就是和之前一样，通过一个静态成员函数在栈区上创建一个类对象，并且将默认构造函数私有化，然后设计静态方法创建对象返回即可。
class StackOnly { public: static StackOnly CreateObject() { return StackOnly(); } private: StackOnly() {} };
此时 new 一个对象的时候，由于默认构造函数私有而无法调用，所以报错。
但以上两种设计方法都有一个漏洞，类对象可以在静态区（数据段）上创建：
static StackOnly so = StackOnly::CreateObject();
设计特殊类的核心：只能通过静态成员函数来创建类，封掉其他所有创建方式。
四、设计一个类，不能被继承
1、C++98 方式
C++98 中构造函数私有化，派生类中调不到基类的构造函数则无法继承。
// 基类 class NonInherit { private: // 基类构造函数私有 NonInherit() {} }; // 派生类 class B : public NonInherit {};
2、C++11 方法
使用 final 关键字来修饰类，表示该类不能被继承。
class A final {};
五、设计一个类，只能创建一个对象（单例模式）
1、设计模式
设计模式 （Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的 总结。
为什么会产生设计模式这样的东西呢？
就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
2、单例模式（一种设计模式）
- 单例模式：一个类只能创建一个对象。
- 该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
- 全局只有一个实例对象，所以将单例对象放在静态区 / 堆区（保证只创建一次）。
- 为了防止其他位置创建该对象，将构造函数私有。
- 为了防止拷贝，使用 delete 修饰拷贝构造和赋值运算符重载函数。
单例模式有两种实现模式：
（1）饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
// 饿汉模式 class Singleton { public: // 获取单例对象接口 static Singleton* GetInstance() { return &m_instance; } private: // 构造函数私有 Singleton() {}; // C++98 防拷贝 Singleton(Singleton const& s); Singleton& operator=(Singleton const& s); // or // C++11 Singleton(const Singleton& s) = delete; // 禁止使用拷贝构造 Singleton& operator=(const Singleton& s) = delete; // 禁止使用赋值运算符重载 // 保证单例对象在静态区且只有一个 static Singleton m_instance; // 单例对象 }; // 在程序入口之前就完成单例对象的初始化 Singleton* Singleton::m_instance = new Singleton; int main() { cout << Singleton::GetInstance() << endl; cout << Singleton::GetInstance() << endl; cout << Singleton::GetInstance() << endl; return 0; }
静态成员变量只能在类域外进行定义初始化。
所以在 main 函数之前就将单例对象定义初始化，此时该单例对象创建在静态区上，而且仅有一个，后面就无法再创建。
- 想要获取该单例对象只能通过静态成员函数 GetInstance() 来获取。
- 静态成员函数可以直接访问静态成员变量 m_instance。
int main() { Singleton* s = Singleton::GetInstance(); // 获取单例对象 return 0; }
为什么称之为饿汉模式呢？
不管将来会不会使用到这个单例对象，但是在程序一启动还没有进入 main 函数之前就创建一个唯一的实例对象。就像一个饿汉一样，一上来就先吃（创建单例对象）。
【总结】
1、如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。
2、饿汉单例模式优点：
- 保证全局（整个进程）只有唯一实例对象。
- 饿汉模式：一开始就创建对象，特别简单。
3、饿汉单例模式缺点：
- 多个单例对象 A、B、C 假设要求他们之间有依赖关系：依次创建就无法达到，无法保证顺序可能会导致进程启动很慢。
如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避
免资源竞争，提高响应速度更好。
（2）懒汉模式
// 懒汉模式 #include <iostream> #include <mutex> #include <thread> using namespace std; class Singleton { public: static Singleton* GetInstance() { // 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全 if (nullptr == m_pInstance) { // 如果单例对象没有创建则在堆区创建 if (nullptr == m_pInstance) { m_pInstance = new Singleton(); } return m_pInstance; } } // 实现一个内嵌垃圾回收类 class CGarbo { public: ~CGarbo() { if (Singleton::m_pInstance) delete Singleton::m_pInstance; } }; // 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象 static CGarbo Garbo; private: // 构造函数 Singleton(){}; // 防拷贝 Singleton(const Singleton& s) = delete; // 禁止拷贝 Singleton& operator=(const Singleton& s) = delete; // 禁止赋值 //静态单例对象指针 static Singleton* m_pInstance;//单例对象指针 static mutex m_mtx; //互斥锁 }; Singleton* Singleton::m_pInstance = nullptr; // 初始化为空 Singleton::CGarbo Garbo; mutex Singleton::m_mtx; void func(int n) { cout << Singleton::GetInstance() << endl; } // 多线程环境下才能演示上面GetInstance()加锁和不加锁的区别 int main() { thread t1(func, 10); thread t2(func, 10); t1.join(); t2.join(); cout << Singleton::GetInstance() << endl; cout << Singleton::GetInstance() << endl; return 0; }
这里出现了一个有关线程安全的问题。当多线程时，进行判断为 nullptr，这时还没有调用 new，当前的线程就被切走了。下一个线程来了还是 nullptr 就又进去 new 了一个对象，然后恢复第一个线程的上下文后又 new 了一个对象，第二个 new 的就将第一个的给覆盖了，所以就出现了错误。
这里我们就可以使用互斥锁：
因为加锁需要加在一个锁上才有用，所以我们也要将锁设为静态的，然后在类外进行初始化，这样就保证了只实例化出一个对象来，但实际上这样还是有问题的。
当我们 new 出一个对象之后，我们在进行调用 GetInstance 的时候，还会不停的加锁解锁。加锁解锁是有性能消耗的，所以不断的加锁解锁是很不好的，所以这里我们要使用双检测加锁：
这样减少了加锁，提高了效率，但还是会有一点问题，单例对象什么时候释放呢？
其实单例对象是不需要释放的。因为在一般情况下，单例在进程启动之后随时会被使用，而且这个对象也不大，所以就可以不去释放它。那么会有内存泄漏吗？
如果进程是正常结束的，因为 new 出来得到的进程地址空间是虚拟内存，当结束之后就会将地址通过页表取消映射，那么 new 出来的资源就会还给 OS。当然如果想要释放也是没有问题的：
实现一个 DelInstance 手动调用的去释放。
当然有可能考虑到程序结束时，需要处理一下持久化保存一些数据，比方说要将数据写到硬盘上。那么可以写一个析构函数，在析构函数中去处理。如果担心会忘记手动调用 DelInstance ，那么可以通过设计一个类，在类中实现一个析构函数。
上面就是在创建的时候创建一个 _gc。当 main 结束时，_gc 生命周期结束，然后调用它的析构函数，直接将单例对象进行析构。
- 同样将构造函数私有，拷贝构造和赋值运算符重载函数禁止调用，用来保证单例模式的唯一性。
- 增加静态单例对象指针成员变量。
在类外实例化静态指针变量的时候，并没有创建单例对象，而是将其初始化为空。
int main() { Singleton* ps = Singleton::GetInstance();//获取单例对象 return 0; }
在获取单例对象时，如果是第一次使用，那么就会在堆区上 new 一个单例对象，并且将所在地址赋值给静态的成员指针变量。
为什么称之为懒汉模式呢？
懒汉模式又叫做延时加载模式。如果单例对象构造十分耗时或者占用很多资源，比如加载插件、初始化网络连接、读取文件等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢，所以这种情况使用懒汉模式（延迟加载）更好。
【优点】
- 第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序（通过代码顺序）自由控制。
【缺点】
- 复杂。
- 如果不加锁是会出现线程安全的问题。但是加锁是会十分影响性能的，所以引入了双检查。那么既要保证线程安全+又要保证效率的问题。
