类似vector的ProArray封装类CProArray

　　在做ProE二次开发的时候，时常会用到数组ProArray，虽然掌握之后并不难，但是用法毕竟不简洁，有时候难免出错，比如用ProArrayAlloc申请了一数组，但忘了释放，这就会导致内存泄露，等等。

　　我们知道，C++的标准库STL中有vector，完全可以替代C中难用的原生数组，所以我想，可不可以写一个类似vector的类来封装ProArray呢？

经过一段时间的编码，终于完成了这个类似vector的CProArray类，代码如下：

CProArray.h

#ifndef _C_PRO_ARRAY_H_
#define _C_PRO_ARRAY_H_

#include <ProToolkit.h>
#include <ProArray.h>
#include <exception>
#include <stdexcept>

using std::exception;
using std::out_of_range;
using std::bad_alloc;

template<class TYPE, size_t reallocationSize>
class CProList;

template<class TYPE, size_t reallocationSize = 5>
class CProArray
{
    friend class CProList<TYPE, reallocationSize>;

public:
    CProArray() 
        //throw(bad_alloc)
        : m_arr(NULL), m_nCntAdd(reallocationSize), use(1)
    {
        if (reallocationSize == 0)  m_nCntAdd = 5;
        if (PRO_TK_OUT_OF_MEMORY == ProArrayAlloc(0, sizeof(TYPE), m_nCntAdd, &m_arr))
            throw bad_alloc("out of memory.");
    }

    ~CProArray()
    {
        ProArrayFree(&m_arr);
    }

    CProArray(const CProArray& arrSrc) 
        //throw(bad_alloc)
        : m_arr(NULL), m_nCntAdd(reallocationSize), use(1)
    {
        if (reallocationSize == 0)    m_nCntAdd = 5;
        if (PRO_TK_OUT_OF_MEMORY == ProArrayAlloc(0, sizeof(TYPE), m_nCntAdd, &m_arr))
            throw bad_alloc("out of memory.");
        size_t nSizeSrc = arrSrc.size();
        if (0 != nSizeSrc)
        {
            if (PRO_TK_OUT_OF_MEMORY == ProArrayObjectAdd(&m_arr, -1, nSizeSrc, arrSrc.m_arr))
                throw bad_alloc("out of memory.");
        }
    }

    CProArray& operator=(const CProArray& arrSrc) 
        //throw(bad_alloc)
    {
        clear();
        size_t nSizeSrc = arrSrc.size();
        if (0 != nSizeSrc)
        {
            if (PRO_TK_OUT_OF_MEMORY == ProArrayObjectAdd(&m_arr, -1, nSizeSrc, arrSrc.m_arr))
                throw bad_alloc("out of memory.");
        }
    }

public:
    size_t size() const
    {
        int nSize;
        ProArraySizeGet(m_arr, &nSize);
        return nSize;
    }

    bool is_empty() const
    {
        return !size();
    }

    void clear()
    {
        if (0 != size())
            ProArrayObjectRemove(&m_arr, 0, size());
    }

    void push_back(const TYPE& val) 
        //throw(bad_alloc)
    {
        if (PRO_TK_OUT_OF_MEMORY == ProArrayObjectAdd(&m_arr, -1, 1, (void*)(&val)))
            throw bad_alloc("out of memory.");
    }

    void pop_back()
    {
        if (!is_empty())
            ProArrayObjectRemove(&m_arr, -1, 1);
    }

    const TYPE& front() const 
        //throw(out_of_range)
    {
        if (is_empty())
            throw out_of_range("empty CProArray.");
        return reinterpret_cast<const TYPE*>(m_arr)[0];
    }

    TYPE& front() 
        //throw(out_of_range)
    {
        return const_cast<TYPE&>(const_cast<const CProArray*>(this)->front());
    }

    const TYPE& back() const 
        //throw(out_of_range)
    {
        if (is_empty())
            throw out_of_range("empty CProArray.");
        return  reinterpret_cast<const TYPE*>(m_arr)[size()-1];
    }

    TYPE& back() 
        //throw(out_of_range)
    {
        return const_cast<TYPE&>(const_cast<const CProArray*>(this)->back());
    }

    const TYPE& operator[](size_t index) const 
        //throw(out_of_range)
    {
        if (is_empty())
            throw out_of_range("empty CProArray.");
        if (size() <= index)
            throw out_of_range("invalid index of CProArray.");
        return reinterpret_cast<const TYPE*>(m_arr)[index];
    }

    TYPE& operator[](size_t index) 
        //throw(out_of_range)
    {
        return const_cast<TYPE&>(const_cast<const CProArray*>(this)->operator[](index));
    }

    const TYPE& at(size_t index) const 
        //throw(out_of_range)
    {
        if (is_empty())
            throw out_of_range("empty CProArray.");
        if (size() <= index)
            throw out_of_range("invalid index of CProArray.");
        return reinterpret_cast<const TYPE*>(m_arr)[index];
    }

    TYPE& at(size_t index) 
        //throw(out_of_range)
    {
        return const_cast<TYPE&>(const_cast<const CProArray*>(this)->at(index));
    }

    void insert_at(size_t index, const TYPE& val) 
        //throw(out_of_range, bad_alloc)
    {
        if (size() < index)
            throw out_of_range("invalid index of CProArray.");
        if (size() == index)
            index = -1;
        if (PRO_TK_OUT_OF_MEMORY == ProArrayObjectAdd(&m_arr, index, 1, (void*)(&val)))
            throw bad_alloc("out of memory.");
    }

    void insert_at(size_t index, size_t cnt, const TYPE *pVal) 
        //throw(out_of_range, bad_alloc)
    {
        if (size() < index)
            throw out_of_range("invalid index of CProArray.");
        if (size() == index) 
            index = -1;
        if (PRO_TK_OUT_OF_MEMORY == ProArrayObjectAdd(&m_arr, index, cnt, (void*)pVal))
            throw bad_alloc("out of memory.");
    }

    void remove_at(size_t index, size_t cnt = 1) 
        //throw(out_of_range)
    {
        if (size() <= index)
            throw out_of_range("invalid index of CProArray.");
        if (size() - index < cnt)
            throw out_of_range("count to remove is out of range.");
        ProArrayObjectRemove(&m_arr, index, cnt);
    }

    operator ProArray() const
    {
        return m_arr; 
    }

public:
    ProArray m_arr;
private:
    int m_nCntAdd;
    size_t use;
};

#endif

代码说明：

1、该类代码经过我反复测试，应该不存在Bug。

2、该类的方法名完全参考vector类的方法名，内部全部是用ProArray的原生方法实现的。

3、在构造函数中通过ProArrayAlloc申请了内存，在析构函数中通过ProArrayFree释放了内存，所以避免了内存泄露。

4、该类有属性为public的ProArray成员m_arr，如果在某些代码处，需要通过ProArray原生方法操作数组，直接获取该成员即可。

5、该类在使用过程中，若出现访问越界等错误，会抛出异常。

6、该类使用C++的模板元编程实现。

7、由于每个方法代码都很短，所以全部写在头文件中，即全部为内联函数。

使用Demo：

CProArray<int> nArr;
nArr.push_back(6);
nArr.push_back(7);
for (int i=0; i<nArr.size(); ++i)
{
	CString cstr;
	cstr.Format(TEXT("%d"), nArr[i]);
	AfxMessageBox(cstr);
}