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

设计一个只能在栈上创建对象的类

反过来，如果希望对象必须在栈上创建，就不能允许使用 new。这可以通过私有化构造函数，并删除全局 operator new 来实现。

注意，这里不能提供静态工厂函数返回指针，否则用户会误以为可以堆分配。应该返回对象本身。

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

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

设计一个不能被继承的类

当类的实现细节不希望被子类修改时，我们需要禁止继承。C++98 时期同样是通过私有化构造函数来达成，但这会导致无法创建对象（除非友元），比较麻烦。C++11 引入的 final 关键字则优雅得多。

class Base final {
public:
    Base() {}
    virtual void func() {}
};
// class Derived : public Base {}; // 编译错误

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

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

饿汉模式

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

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 类正是利用了局部静态对象的析构时机来保证这一点。