C++ 单例模式对象释放的问题

std::mutex resource_mutex;
class MyCAS //  这是一个单例类
{
private:
    MyCAS() {}//私有化构造函数

private:
    static MyCAS* m_instance;//静态成员变量
    

public:
    static MyCAS* getInstance()
    {
        if (m_instance == nullptr)
        {
            std::unique_lock<std::mutex> myMutex(resource_mutex);//自动加锁
            if (m_instance == nullptr)
            {
                m_instance = new MyCAS();
                static CgarRes cl;  // 当程序退出时候， cl必然会调用自己类的析构， 所以会析构 MyCAS::m_instance 
            }
        }
        
        return m_instance;
    }

    class CgarRes   //类中嵌套，用来释放对象
    {
    public:
        ~CgarRes()
        {
            if (MyCAS::m_instance)
            {
                delete MyCAS::m_instance;
                MyCAS::m_instance = nullptr;
            }
        }
    };
    
    void func()
    {
        cout << "test" << endl;
   }


};

//类静态变量初始化
MyCAS* MyCAS::m_instance = nullptr;

int main()
{
    MyCAS* p_a = MyCAS::getInstance();
    return 0;
}

其实单实例的对象， 在对象析构时，编译器会自动释放实例指针。这里只是了解了一种可以释放的思路。

std::mutex resource_mutex 是为了多线程访问单实例的时候， 线程执行上下文切换时，可能出现的安全问题，导致创建出两个实例对象。

其实这点在C++11中已经有更加搞笑的解决方法：

void call_once (once_flag& flag, Fn&& fn, Args&&...args);

        第一个参数是std::once_flag的对象(once_flag是不允许修改的，其拷贝构造函数和operator=函数都声明为delete)，第二个参数可调用实体，即要求只执行一次的代码，后面可变参数是其参数列表。

这个的轻轻壳参考：https://blog.youkuaiyun.com/xijiacun/article/details/71023777

示例：

static std::once_flag oc;  // 用于call_once的局部静态变量

        Singleton* Singleton::m_instance;

        Singleton* Singleton::getInstance() {

            std::call_once(oc, [&] () {  m_instance = new MyCAS();
                static CgarRes cl; 
            });

            return m_instance;

        }