单例模式的自动析构

总所周知，单例模式如果不主动调用，在进程结束时是不会析构的，而是仅仅把内存释放掉而已
所以，如果希望在析构时进行某些操作，在进程结束前，可以主动调用析构函数，如下面类中的delMe函数(xSingleton::getMe().delMe();)
可是，如果每定义这样一个类，都需要手动析构，实在是个麻烦的事，还常常会忘记。嘿嘿，于是利用构造函数和析构函数总是成对出现的原理，定义一个静态对象，程序结束时，静态对象必然被析构，于是在静态对象的析构函数里将单例模式的类也析构了，哈哈，这样就不用每次手动析构了

class xSingleton
{
    private:
        xSingleton(const xSingleton &);
        const xSingleton &operator=(const xSingleton &);

    public:
        class CGarbo
        {   
            public:
                ~CGarbo()
                {   
                    if(_instance)
                        delete(_instance);
                    printf("CGarbo:delete\n");
                }   
                CGarbo()
                {   
                    printf("CGarbo::add\n");
                }  
        };  
        //static CGarbo garbo;                -------------------------(1)

   protected:
        static xSingleton *_instance;
        xSingleton()
        {   
            printf("xSingleton::add\n");
            static CGarbo garbo;              -------------------------(2)
        }   
        virtual ~xSingleton(){
            printf("xSingleton::delete\n");
        }   

 public:
   /*     static void delMe()
        {   
            if(_instance)
                delete(_instance);
        }
*/ 
        static xSingleton& getMe()
        {
            if (!_instance)
                _instance = new xSingleton;
            return *_instance;
        }
};