좋 은 C++프로 그래 밍 습관 을 기 르 는 메모리 관리 에 대한 상세 한 설명

// T                 :     （        ）
// MAX_CACHE_SIZE    :           ，  sizeof(T)    ，        ，  
//                                buffer          
template<class T, size_t MAX_CACHE_SIZE = 0>
class CBufferPtrT
{
public:
    explicit CBufferPtrT(size_t size = 0, bool zero = false)    {Reset(); Malloc(size, zero);}
    explicit CBufferPtrT(const T* pch, size_t size)    {Reset(); Copy(pch, size);}
    //             
    CBufferPtrT(const CBufferPtrT& other)    {Reset(); Copy(other);}
    template<size_t S> CBufferPtrT(const CBufferPtrT<T, S>& other)    {Reset(); Copy(other);}
    ~CBufferPtrT() {Free();}
    T* Malloc(size_t size = 1, bool zero = false)
    {
        Free();
        return Alloc(size, zero, false);
    }
    T* Realloc(size_t size, bool zero = false)
    {
        return Alloc(size, zero, true);
    }
    void Free()
    {
        if(m_pch)
        {
            free(m_pch);
            Reset();
        }
    }
    template<size_t S> CBufferPtrT& Copy(const CBufferPtrT<T, S>& other)
    {
        if((void*)&other != (void*)this)
            Copy(other.Ptr(), other.Size());
        return *this;
    }
    CBufferPtrT& Copy(const T* pch, size_t size)
    {
        Malloc(size);
        if(m_pch)
            memcpy(m_pch, pch, size * sizeof(T));
        return *this;
    }
    //      buffer
    template<size_t S> CBufferPtrT& Cat(const CBufferPtrT<T, S>& other)
    {
        if((void*)&other != (void*)this)
            Cat(other.Ptr(), other.Size());
        return *this;
    }
    //      buffer
    CBufferPtrT& Cat(const T* pch, size_t size = 1)
    {
        size_t pre_size = m_size;
        Realloc(m_size + size);
        if(m_pch)
            memcpy(m_pch + pre_size, pch, size * sizeof(T));
        return *this;
    }
    template<size_t S> bool Equal(const CBufferPtrT<T, S>& other) const
    {
        if((void*)&other == (void*)this)
            return true;
        else if(m_size != other.Size())
            return false;
        else if(m_size == 0)
            return true;
        else
            return (memcmp(m_pch, other.Ptr(), m_size * sizeof(T)) == 0);
    }
    bool Equal(T* pch) const
    {
        if(m_pch == pch)
            return true;
        else if(!m_pch || !pch)
            return false;
        else
            return (memcmp(m_pch, pch, m_size * sizeof(T)) == 0);
    }
    T*    Ptr()    {return m_pch;}
    const T*    Ptr()    const    {return m_pch;}
    T&    Get(int i)    {return *(m_pch + i);}
    const T&    Get(int i)    const    {return *(m_pch + i);}
    size_t    Size()    const    {return m_size;}
    bool    IsValid()    const    {return m_pch != 0;}
    //   ，        
    operator    T*    ()    {return Ptr();}
    operator const    T*    ()    const    {return Ptr();}
    //   ，         
    T& operator    []    (int i)    {return Get(i);}
    const T& operator    []    (int i)    const    {return Get(i);}
    bool operator    ==    (T* pv)    const    {return Equal(pv);}
    template<size_t S> bool operator    ==    (const CBufferPtrT<T, S>& other)    {return Equal(other);}
    //            
    CBufferPtrT& operator    =    (const CBufferPtrT& other)    {return Copy(other);}
    template<size_t S> CBufferPtrT& operator    =    (const CBufferPtrT<T, S>& other)    {return Copy(other);}
private:
    void Reset()    {m_pch = 0; m_size = 0; m_capacity = 0;}
    size_t GetAllocSize(size_t size)    {return max(size, min(size * 2, m_size + MAX_CACHE_SIZE));}
    T* Alloc(size_t size, bool zero = false, bool is_realloc = false)
    {
        if(size >= 0 && size != m_size)
        {
            size_t rsize = GetAllocSize(size);
            if(size > m_capacity || rsize < m_size)
            {
                m_pch = is_realloc                            ?
                   　(T*)realloc(m_pch, rsize * sizeof(T))    :
                　　　(T*)malloc(rsize * sizeof(T))            ;
                if(m_pch || rsize == 0)
                {
                    m_size        = size;
                    m_capacity    = rsize;
                }
                else
                    Reset();
            }
            else
                m_size = size;
        }
        if(zero && m_pch)
            memset(m_pch, 0, m_size * sizeof(T));
        return m_pch;
    }
private:
    T*        m_pch;
    size_t    m_size;
    size_t    m_capacity;
};
//    buffer     typedef
typedef CBufferPtrT<char>            CCharBufferPtr;
typedef CBufferPtrT<wchar_t>        CWCharBufferPtr;
typedef CBufferPtrT<unsigned char>    CByteBufferPtr;
typedef CByteBufferPtr                CBufferPtr;
#ifdef _UNICODE
    typedef CWCharBufferPtr            CTCharBufferPtr;
#else
    typedef CCharBufferPtr            CTCharBufferPtr;
#endif

     
 int _tmain(int argc, _TCHAR* argv[])
 {
     CBufferPtr buffer;

     unsigned char c1    = 'X';
     unsigned char pc1[] = "123";
     unsigned char pc2[] = "abc";
     buffer.Cat(&c1);
     buffer.Cat(pc1, 3);
     buffer.Cat(pc2, 3);

     CBufferPtrT<unsigned char, 10> buffer2 = buffer;
     buffer2.Cat(buffer);
     buffer2.Realloc(0);

     unsigned char* pc = buffer;
     const unsigned char& c = buffer[5];
     buffer[5] = 'O';

     short i1    = 0x7FFF;
     short pi0[] = {9,9,9};
     short pi1[] = {1,2,3};
     short pi2[] = {4,5,6};
     short pi3[] = {8,8,8};

     CBufferPtrT<short, 10> bufferS(pi0, 3);

     bufferS.Cat(&i1);
     bufferS.Cat(pi1, 3);
     bufferS.Cat(pi2, 3);
     bufferS.Cat(pi3, 3);

     CBufferPtrT<short, 5> bufferS2;
     bufferS2.Malloc(4);

     bufferS2 = bufferS;
     bufferS2.Realloc(30);

     CBufferPtrT<int> bufferI(5, true);

     for(size_t i = 0; i < bufferI.Size(); i++)
         bufferI[i] = i *10;

     bufferI.Malloc();
     bufferI[0] = 123;

     //          ，             
 // bufferI = bufferS;

     return 0;
 }