C++使用宏函数实现单例模板详解

#pragma once
#include <stdlib.h>
#include <assert.h>
#include <thread>
#include <mutex>






#define SINGLETON_CLASS_DEFAULT(Class)                                          \
    private:                                                                    \
        Class() {}                                                              \
        ~Class() {}                                                             \
        Class(Class &other) {}                                                  \
        Class(const Class &other) {}                                            \
        Class& operator=(Class &other) {}                                       \
        Class& operator=(const Class &other) {}                                 \


#define SINGLETON_CLASS_FUNC_DECL(Class)                                        \
    public:                                                                     \
        static Class& Ins();                                                    \
    private:                                                                    \
        static void InitSingleton();                                            \
                                                                                \
        static void Release();                                                  \
                                                                                \
        SINGLETON_CLASS_DEFAULT(Class)                                          \
private:                                                                        \
    static std::once_flag m_singletonFlag;                                      \
    static Class* m_ins;

                         


#define SINGLETON_CLASS_FUNC_IMPL(Class)                                        \
    Class& Class::Ins() {                                                       \
        \
                   \
                              \
           \
         \
                  \
                \
        std::call_once(m_singletonFlag, &Class::InitSingleton);                 \
        assert(m_ins != NULL);                                                  \
        return *m_ins;                                                          \
    }                                                                           \
                                                                                \
    void Class::InitSingleton() {                                               \
        m_ins = new Class;                                                      \
        if (m_ins) {                                                            \
          \
                                   \
                                                \
                ::atexit(Release);                                              \
        }                                                                       \
    }                                                                           \
                                                                                \
    void Class::Release() {                                                     \
         if (m_ins) {                                                           \
              delete m_ins;                                                     \
              m_ins = NULL;                                                     \
         }                                                                      \
    }                                                                   


#define SINGLETON_CLASS_VARIABLE_IMPL(Class)                                    \
        std::once_flag Class::m_singletonFlag;                                  \
        Class* Class::m_ins = NULL;


#define SINGLETON_CLASS_IMPL(Class)                                             \
        SINGLETON_CLASS_VARIABLE_IMPL(Class)                                    \
        SINGLETON_CLASS_FUNC_IMPL(Class)                                        

#include "ISingleton.hpp"


class Aclass {
    //声明
    SINGLETON_CLASS_FUNC_DECL(Aclass)

public:
    int a;
    
};

#include "Aclass.h"

//定义
SINGLETON_CLASS_IMPL(Aclass);

#include "Aclass.h"
int main() {
    //Aclass a;  err
    Aclass::Ins().a = 5;
    std::cout << Aclass::Ins().a << std::endl;
    return 0;
}