现在代码中越来越多的使用单体类，而我们通常的编写代码的方式是：

在A.h文件中：

class CTest
{
    public:
        static CTest* _ins;
        static CTest* Ins()
};

在A.cpp中：

CTest* CTest::_ins = NULL;
CTest* CTest::Ins()
{
    if ( !_ins )
    {   
        try 
        {   
            _ins = new CTest();
        }   
        catch(...)
        {   
            return NULL;
        }   
    }   
    return _ins;
}

而实际上，上面的代码通过valgrind检查内存泄漏的时候，会告诉你内存still reachable，虽然实际上当进程退出的时候，这些内存是实际释放掉了，但是还是多少会对内存泄漏的定位产生影响，而且也不符合谁申请谁释放的原则。

我们可以简单的使用stl的智能指针解决这个问题，即代码更改如下：

在A.h文件中：

class CTest
{
    public:
        static auto_ptr<CTest> m_auto_ptr;
        static CTest* _ins;
        static CTest* Ins();
};

在A.cpp中：

auto_ptr<CTest> CTest::m_auto_ptr;
CTest* CTest::_ins = NULL;
CTest* CTest::Ins()
{
    if ( !_ins )
    {   
        try 
        {   
            _ins = new CTest();
        }   
        catch(...)
        {   
            return NULL;
        }   
    }   
    return _ins;
}
CTest::CTest()
{
    m_

auto_ptr = auto_ptr<CTest>(this);
}

OK，这样valgrind的内存检查就可以通过了，但是实际上构建一个单体类要比我们的代码复杂的多，比如要考虑copy构造函数的问题，因为有可能有人会这样使用 CTest = *CTest::Ins(); 而这样明显是不可以的，还有就是肯定不能允许别人delete掉唯一的ins，所以析构函数应该为private或者protected等等,还有构造函数应该为private等等。

在这里贴出一份比较合理的代码，其实就是我写的load_template.vim插件的一个标准模板。

A.h

#ifndef _X_H_
#define _X_H_
#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;
class CTest
{
    private:
        static auto_ptr<CTest> m_auto_ptr;
        static CTest * m_ins;
    public:
        static CTest * Ins();
    protected:
        CTest();
        CTest(const CTest&);
        virtual ~CTest();
        friend class auto_ptr<CTest>; 
};
#endif

A.cpp

#include "x.h"
CTest* CTest::m_ins = NULL;
auto_ptr<CTest> CTest::m_auto_ptr;
CTest::CTest()
{
    m_auto_ptr = auto_ptr<CTest>(this);
}
CTest::~CTest()
{
}
CTest* CTest::Ins()
{
    if ( m_ins == NULL)
        m_ins = new CTest();
    return m_ins;
}