C++ 特殊类设计：拷贝控制、内存分配与单例模式

关于这里的 operator new，默认调用的是全局 new。在这个类里这样处理后，这个类就无法使用 new 了，从而强制对象在栈上分配。

设计一个不能被继承的类

有两种主流实现方式：

1. C++98 方法： 让构造函数私有化。这样派生类无法访问基类构造函数，从而无法继承。
2. C++11 方法： 使用 final 关键字修饰类名。

class FinalClass final {
    // ... 类内容
};
// class Derived : public FinalClass {}; // 编译错误

设计一个只能创建一个对象的类（单例模式）

单例模式保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

饿汉模式

优点： 实现简单，线程安全。 缺点： 如果单例对象初始化内容很多，会影响启动速度；如果两个单例类互相有依赖关系，对实例化的顺序有要求，但饿汉模式难以控制实例化顺序（尤其是在不同的编译单元）。

namespace hungry {
class Singleton {
public:
    static Singleton& GetInstance() {
        return _sinst;
    }

private:
    Singleton() {}
    // 防拷贝
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;
    
    static Singleton _sinst;
};
Singleton Singleton::_sinst;
}

懒汉模式

懒汉模式意味着程序启动时，单例对象并没有被创建，仅仅是定义了一个指向它的空指针。直到第一次调用 GetInstance 时才进行初始化。

一般单例不需要手动释放，因为程序结束时操作系统会自动回收。除非特殊场景：中途需要显示释放，或者程序结束时需要做一些特殊动作（比如持久化）。如果是持久化场景，需要在程序结束时将数据写入其他地方，这时就需要调用析构函数。利用一个内部临时类 tmp 可以保证其析构函数会在程序结束时起作用。

namespace lazy {
class Singleton {
public:
    static Singleton& GetInstance() {
        if (_psinst == nullptr) {
            _psinst = new Singleton();
        }
        return *_psinst;
    }

    static void DelInstance() {
        if (_psinst) {
            delete _psinst;
            _psinst = nullptr;
        }
    }

private:
    Singleton() {}
    ~Singleton() {}
    
    // 防拷贝
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;

    static Singleton* _psinst;
    static tmp _tmp;

    class tmp {
    public:
        ~tmp() {
            Singleton::DelInstance();
        }
    };
};

Singleton* Singleton::_psinst = nullptr;
Singleton::tmp Singleton::_tmp;
}

通过上述设计，我们可以灵活地控制 C++ 类的生命周期与访问权限，提升代码的健壮性与安全性。