C++-特殊类设计
不能被拷贝的类
class CopyBan
{// ...private:CopyBan(const CopyBan&);CopyBan& operator=(const CopyBan&);/*c++11:可以直接删除这两个函数CopyBan(const CopyBan&)=delete;CopyBan& operator=(const CopyBan&)=delete;
*/// ...
};- 将拷贝构造函数和赋值运算符重载只声明而不定义。这样类不会自动生成默认的拷贝构造函数和赋值运算符重载；且当前只是两个函数的声明，没有定义也无法调用。因此类内外都无法调用拷贝构造函数和赋值运算符重载。
- 将拷贝构造函数和赋值运算符重载声明为私有。这是因为在public限制符下，如果用户在类外定义这两个函数，就可以使用拷贝构造了，但是一但声明为私有，就算定义了在类外也无法调用。
- 这种方式下，仍然无法完全禁止拷贝，如下：
class CopyBan
{CopyBan* getCopy(){return new CopyBan(*this);//调用了拷贝构造}private:CopyBan(const CopyBan&);CopyBan& operator=(const CopyBan&);
};
CopyBan::CopyBan(const CopyBan&)
{//拷贝构造的实现
}不过，使用c++11新引入特性delete删除相应拷贝函数，无论如何也无法调用了，解决了这个问题。
只能在堆上创建对象的类
本质就是要让我们控制创建对象的方式，而创建对象与构造函数有关（包括拷贝构造）。
class HeapOnly
{
public: static HeapOnly* CreateObject() { return new HeapOnly; }
private: HeapOnly() {}HeapOnly(const HeapOnly&)；/*c++11:private:HeapOnly() {}HeapOnly(const HeapOnly&) = delete;
*/};- 将构造函数私有化。阻止类外使用构造函数定义对象。
- 将拷贝构造函数只声明而不定义。这样类不会自动生成默认的拷贝构造函数；且当前只是这个函数的声明，没有定义也无法调用。因此类内外都无法调用拷贝构造函数，所以不会有拷贝堆上的对象从而在栈上创建对象的可能。
- 将拷贝构造函数声明为私有。这是因为在public限制符下：如果用户在类外定义这个函数，就可以使用拷贝构造了，但是一但声明为私有，就算定义了在类外也无法调用。
- 这种方式下，仍然可以在可以在栈上创建对象：
class HeapOnly
{
public:static HeapOnly* CreateObject(){return new HeapOnly;}void func() {HeapOnly x;//在栈上定义对象}
private:HeapOnly() {}HeapOnly(const HeapOnly&);/*c++11:private:HeapOnly() {}HeapOnly(const HeapOnly&) = delete;*/
};
HeapOnly::HeapOnly(const HeapOnly& x)
{//拷贝函数
}不过，不过，使用c++11新引入特性delete删除相应拷贝构造函数，无论如何也无法调用了，解决了这个问题。
只在栈上创建对象的类
本质就也是要让我们控制创建对象的方式，而创建对象与构造函数有关（包括拷贝构造）。
class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}void* operator new(size_t size) = delete;void operator delete(void* p) = delete;/*
private:void* operator new(size_t size);void operator delete(void* p);
也可以这样定义来防止new和delete，但是也会出现在“不能被拷贝的类”中出现的问题：类外
定义operator new和operator delete，在类内定义成员函数调用它们。
*/
private:StackOnly() :_a(0){}
private:int _a;
};- 将构造函数私有化。阻止类外使用构造函数定义对象。而我们提供一个统一的接口供于创建对象。
- 拷贝构造不能禁止。这样会导致对象创建接口无法返回在栈上创建的对象。而且拷贝构造还得是public权限。
- 将operator new和operator delete禁用掉。直接使这个类无法被new，其也就无法通过new和拷贝构造来创建一个动态空间的类对象了。
为什么能禁用？
虽然 operator new 不是默认成员函数，但如果你在类中声明了它（即使是 = delete），编译器会优先查找类专属版本，而不会再使用全局版本。也就是说，在上面的例子中，全局的new和delete也被类内的声明给隐藏了，调用不到而类中的new和delete被删除了，也掉用不了。所以对于该类来说，无法new。
不能被继承的类
class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
};- 将类的构造函数定义为私有，这样继承该类的类不可见该类的构造函数，也就无法正确构造对象，继承无法进行。为了该类能正常构造，类内定义了专门的接口用来创建对象。
只能创建一个对象的类（单例模式）
需要禁止一切类外的构造，包括拷贝构造。
饿汉模式
// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:static Singleton* GetInstance(){return &m_instance;}private:// 构造函数私有Singleton() {};// 防拷贝Singleton(Singleton const&);Singleton& operator=(Singleton const&);//其实没必要禁止赋值。/*C++11Singleton(Singleton const&) = delete;Singleton& operator=(Singleton const&) = delete;*/ static Singleton m_instance;
};Singleton Singleton::m_instance{};//直接定义出实例来把m_instance定义为static变量原因有二：
- 获取唯一实例的接口必须是静态函数，而静态函数只能访问静态变量
- 将m_instance定义为static可以保证它只有一份
饿汉模式优点：
- 线程安全。由于静态变量的初始化是在主线程执行之前完成的，所以饿汉模式是线程安全的。
- 程序运行速度快。由于饿汉模式在程序启动时就已经创建了实例，所以每次调用
GetInstance()函数时都不需要再进行判断和创建实例，可以提高程序运行速度。
饿汉模式缺点：
-
在一个程序中如果有多个单例，并且有先后创建初始化顺序要求时，饿汉无法控制。例如，程序两个单例类A 和 B，假设要求A先创建初始化，B再创建初始化。然而静态成员谁先初始化是不确定的，尤其是多个文件 （单个文件可能是按顺序的）。
-
增加程序启动时间。由于饿汉模式在类加载时就创建实例，所以它会增加程序启动时间。
-
可能浪费内存空间。如果最终没有使用该对象，则会浪费内存空间。
懒汉模式
需要的时候再创建实例。
// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点：复杂
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
class Singleton
{
public:static Singleton* GetInstance() {// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全if (nullptr == m_pInstance) {m_mtx.lock();if (nullptr == m_pInstance) {m_pInstance = new Singleton();}m_mtx.unlock();}return m_pInstance;}// 实现一个内嵌垃圾回收类 class CGarbo {public:~CGarbo() {if (Singleton::m_pInstance)delete Singleton::m_pInstance;}};// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象static CGarbo Garbo;
private:// 构造函数私有Singleton() {};// 防拷贝Singleton(Singleton const&);Singleton& operator=(Singleton const&);//其实没必要禁止赋值。/*C++11Singleton(Singleton const&) = delete;Singleton& operator=(Singleton const&) = delete;*/static Singleton* m_pInstance; // 单例对象指针，因为是延迟加载，不能直接定义变量了static mutex m_mtx;//互斥锁
};
//定义static成员
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo{};
mutex Singleton::m_mtx{};该懒汉模式的写法使用了Double-Check（双重校验）+加锁 ：
- 访问GetInstance()需要加锁，否则可能出现两个线程都new出一个实例的情况。加锁后要对指针进行检验，防止后续申请到锁的线程再new出一个实例。这是使用加锁+一重校验保证线程安全。
- 在申请锁之前就先进行一重检验，这可以有效减少线程申请锁的次数：如果指针不为空就不申请锁了。这是使用一重校验保证效率
懒汉模式的优点是：
-
能控制实例化多个对象的顺序。
-
延迟初始化：只有在第一次使用时才会创建单例对象，避免了不必要的资源浪费。
-
简单易实现：相比其他单例模式实现方式，懒汉模式更加简单直接。
懒汉模式的缺点是：
- 线程不安全：如果多个线程同时调用
GetInstance()，可能会创建多个实例。可以通过加锁来解决这个问题，但会增加复杂度和降低性能。 - 延迟加载可能导致程序启动变慢：如果单例对象初始化需要大量时间和资源，那么在第一次调用
GetInstance()时可能会导致程序启动变慢。
单例模式的资源回收
在懒汉模式中，由于类中保存的是指向
Singleton实例的指针，如果在Singleton类的析构函数中编写Singleton实例的销毁机制，比如这样：~singleton() {delete m_pInstance; }析构函数只有在实例销毁的时候才调用，而实例的销毁却需要析构函数，这是死循环。所以不要在析构函数编写实例销毁机制。
内嵌垃圾回收类
在上面的懒汉模式代码中，我们定义了一个内部垃圾回收类 CGarbo，并且在 Singleton 类中定义了一个此类的静态成员 Garbo。程序结束时，系统会自动析构此静态成员，此时，在 GC 类的析构函数中析构 Singleton 实例，就可以实现 m_pInstance 的自动释放。
- 优点：可以自动释放单例对象，避免了内存泄漏的问题。它不需要程序员手动调用 delete 来释放单例对象，也不需要注册释放函数或提供释放接口。
- 缺点：只能在程序结束时释放单例对象，如果需要在程序运行过程中释放单例对象，则需要使用其他方法。
主动释放
在单例类中编写一个DestoryInstance函数，通过它释放单例对象的资源，当不再需要该单例对象时就可以主动调用DestoryInstance释放单例对象。
下面是一个简单的示例代码：
class Singleton
{
public:static Singleton* getInstance(){if (m_pInstance == nullptr)m_pInstance = new Singleton();return m_pInstance;}static void DestoryInstance(){if (m_pInstance != nullptr){delete m_pInstance;m_pInstance = nullptr;}}private:Singleton() {}~Singleton() {}static Singleton* m_pInstance;
};Singleton* Singleton::m_pInstance = nullptr;
在上面的代码中，我们定义了一个静态成员函数 DestoryInstance，用于释放单例对象。当需要释放单例对象时，只需调用此函数即可。
优点：可以在程序运行过程中主动释放单例对象，而不需要等到程序结束时才能释放。这对于一些需要在运行过程中释放资源的应用程序来说非常有用。
缺点：需要程序员手动调用 DestoryInstance 函数来释放单例对象。如果忘记调用此函数，可能会导致内存泄漏的问题。
两种方法的主要区别在于释放单例对象的时机不同。使用内部垃圾回收类的方法只能在程序结束时释放单例对象，而使用 DestoryInstance 函数的方法可以在程序运行过程中主动释放单例对象。
文章参考：特殊类设计及单例模式（C++） - shawyxy - 博客园