C++模板实现，支持多维，安全数组的完整代码

　　经过一番研究及测试，通过．需要的朋友可以参考．有以下特点：

• 完整重载了各必要操作符。
• 区分不同的类型，进行初始化。
• 为了验证，特别增加了测试代码。
• 可以支持多维操作．

　　完整代码如下：

• 头文件

#ifndef __GH_SAFE_ARRAY_H__
#define __GH_SAFE_ARRAY_H__


/**
 * 如何解决memcpy/memset之类的问题？
 * 二维多维数组怎么支持？
 */
template 
class SafeArray
{
public:
    SafeArray();
    SafeArray(const int size);
    SafeArray(const int size, const char* pFile, const char* pFunction, const int nLine);

    ~SafeArray();

    void  init(const int size);
    void  init(const int size, const char* pFile, const char* pFunction, const int nLine);

    int   getSize();
    int   getCurrentOffset();
    bool  isStart();
    bool  isEnd();
    void  resetOffset();

    TYPE& operator[](const int i);
    SafeArray& operator+(const int i);
    SafeArray& operator-(const int i);

    TYPE* operator++(const int i);
    TYPE* operator--(const int i);

    TYPE* operator+=(const int i);
    TYPE* operator-=(const int i);

    //memcpy
    //memset
    //copy
    //clone

private:
    TYPE* m_pData;
    int   m_nSize;

    int   m_nCurrent;

    char* m_pFile;
    char* m_pFunction;
    int   m_nLine;
};

#endif

• 实现文件

/**
在C++面向对象程序设计中，有时候需要判断某个对象的类类型，那么可以有下列两种方法：
方法1：采用 typeid()函数进行判断：（缺点：当存在继承，并且子类指针赋值给父类指针时，此时判断的对象类型为父类型，而不是子类类型）
方法2：定义虚函数返回类类型
在运行时类型识别，最简单的办法就是所有的类（父类和子类）实现一个虚方法返回类名字，根据返回类名字再利用typeid()进行判断。如：
 */

template 
void test(T temp)
{
 //cout= m_nSize )
    {
        GH_LOG_ERROR("Out of Array Range! %d+%d > %d", m_nCurrent, i, m_nSize);
        // 返回第一个元素
        return m_pData[0];
    }
    return m_pData[pos];
}

template 
SafeArray& SafeArray::operator+(const int i)
{
    m_nCurrent += i;
    if (m_nCurrent + i >= m_nSize)
    {
        GH_LOG_ERROR("Out of Array Range! %d+%d > %d", (m_nCurrent-i), i, m_nSize);
        m_nCurrent = 0;
    }
    return (*this);
}

template 
SafeArray& SafeArray::operator-(const int i)
{
    m_nCurrent -= i;
    if (m_nCurrent < 0)
    {
        GH_LOG_ERROR("Out of Array Range! %d-%d < 0", (m_nCurrent+i), i);
        m_nCurrent = 0;
    }
    return (*this);
}

template 
TYPE* SafeArray::operator ++ (const int i)
{
    m_nCurrent ++;
    if (m_nCurrent >= m_nSize)
    {
        GH_LOG_ERROR("Out of Array Range! %d++ >= %d", (m_nCurrent-1), m_nSize);
        m_nCurrent = 0;
        return m_pData;
    }
    return m_pData+m_nCurrent;
}

template 
TYPE* SafeArray::operator -- (const int i)
{
    m_nCurrent --;
    if (m_nCurrent < 0)
    {
        GH_LOG_ERROR("Out of Array Range! %d-1 < 0", (m_nCurrent+1));
        m_nCurrent = 0;
        return m_pData;
    }
    return m_pData+m_nCurrent;
}

template 
TYPE* SafeArray::operator+=(const int i)
{
    m_nCurrent += i;
    if (m_nCurrent >= m_nSize)
    {
        GH_LOG_ERROR("Out of Array Range! %d+%d > %d", (m_nCurrent-i), i, m_nSize);
        m_nCurrent = 0;
        return m_pData;
    }
    return m_pData+m_nCurrent;
}

template 
TYPE* SafeArray::operator-=(const int i)
{
    m_nCurrent -= i;
    if (m_nCurrent < 0)
    {
        GH_LOG_ERROR("Out of Array Range! %d+%d < 0", (m_nCurrent+i), i);
        m_nCurrent = 0;
        return m_pData;
    }
    return m_pData+m_nCurrent;
}

#if 1
void testFor1d(SafeArray& test1d)
{
    test1d.resetOffset();

    test1d ++;
    printf("++   %2d\n", test1d[0]);

    test1d --;
    printf("--   %2d\n", test1d[0]);

    test1d += 16;
    printf("+=16 %2d\n", test1d[0]);

    test1d -= 16;
    printf("-=16 %2d\n", test1d[0]);

    test1d = test1d + 10;
    printf(" +10 %2d\n", test1d[0]);

    test1d = test1d - 10;
    printf(" -10 %2d\n", test1d[0]);
}

int main(int argc, char** argv)
{
#if 0
    //OK
    SafeArray test1d(32);
    for (int i=0; i