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

class StackOnly {
public:
    static StackOnly CreateObj() {
        return StackOnly();
    }

private:
    StackOnly() {}
    ~StackOnly() {}
    
    // 禁止堆分配
    void* operator new(size_t) = delete;
    void* operator new[](size_t) = delete;
    
    // 禁止拷贝
    StackOnly(const StackOnly&) = delete;
    StackOnly& operator=(const StackOnly&) = delete;
};

这里删除 operator new 后，该类就无法使用 new 关键字了，因为默认会调用全局的 new。

设计一个不能被继承的类

禁止类被继承同样有两种经典方案。C++98 风格是通过将构造函数设为私有，使得派生类无法访问基类构造函数从而无法实例化。而 C++11 引入了 final 关键字，这是更现代、更直观的方式。

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

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

单例模式保证系统中该类只有一个实例，并提供全局访问点。常见的实现有饿汉式和懒汉式两种。

饿汉模式

饿汉式在类加载时就初始化实例。优点是线程安全且实现简单；缺点是如果初始化开销大，会影响启动速度，且难以控制不同编译单元间的实例化顺序。

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

private:
    Singleton() {}
    ~Singleton() {}
    
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton _sinst;
};

// 静态成员变量定义
Singleton Singleton::_sinst;
}

懒汉模式

懒汉式则延迟到第一次使用时才创建实例。为了支持线程安全，通常需要加锁，但基础版本如下所示。此外，为了在程序结束时正确清理资源，可以借助局部静态对象的析构机制。

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&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton* _psinst;
    
    // 辅助类，用于程序退出时销毁单例
    class tmp {
    public:
        ~tmp() {
            DelInstance();
        }
    };
    
    static tmp _tmp;
};

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

一般单例不需要手动释放，因为程序结束时操作系统会自动回收。但在特殊场景下，比如中途需要显示释放，或者程序结束时需要持久化数据，就需要调用析构函数。上述代码中的 tmp 类利用了局部静态对象的析构顺序，保证了在 main 函数结束后、程序终止前执行清理逻辑。