xarray.h

BCB的学习资料

{
    if(m_Data != NULL) delete[] m_Data;
    m_Length = 0;
}

/*
////////////////////////////////////////////////////////////////////////////////
[Name]static CopyArray
[Title]复制数组
////////////////////////////////////////////////////////////////////////////////
[param]
    <XArray<T> &>srcArray    原数组
    <int>srcIndex           原数组开始的下标
    <XArray<T> &>destArray   目的数组
    <int>destIndex          目的数组开始的下标
    <int>copySize           复制的数组元素
[Exception]
    Exception  如果发生越界错误，则抛出Exception异常
[Description]
    用memcpy代替了原来的复制算法
    复制数组的数据，从srcArray复制从srcIndex开始的数据，到destArray从destIndex开始的位置，
    复制的大小为copySize
    如果发生数据越界，将会抛出异常

[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
void XArray<T>::CopyArray(const XArray<T> & srcArray,int srcIndex, XArray<T> & destArray, int destIndex, int copySize)
{
    //检查越界
    if( copySize < 0) throw Exception("要复制的大小小于零！");
    if( srcIndex<0 || srcIndex + copySize > srcArray.m_Length ) throw  Exception("要复制内容，超出源数组大小！");
    if( destIndex<0 || destIndex + copySize > destArray.m_Length ) throw Exception("要复制内容，越出目的数组大小！");
    if( &srcArray == &destArray)
    {
        if( destIndex > srcIndex )
        {
            //如果要复制的数据，在目的数据前面，那么就在最后开始复制，避免重复制
            T * src = srcArray.m_Data + srcIndex + copySize - 1;
            T * dest = destArray.m_Data + destIndex + copySize -1;
            for(int i=0; i<copySize; i++)
            {
                *dest = *src;
                dest--;
                src--;
            }
        }
        else if( destIndex < srcIndex )
        {
            T * src = srcArray.m_Data + srcIndex;
            T * dest = destArray.m_Data + destIndex;
            for(int i=0; i<copySize; i++)
            {
                *dest = *src;
                dest++;
                src++;
            }
        }
    }
    else
    {
        T * src = srcArray.m_Data + srcIndex;
        T * dest = destArray.m_Data + destIndex;
        for(int i=0; i<copySize; i++)
        {
            *dest = *src;
            dest++;
            src++;
        }
    }
}

/*
////////////////////////////////////////////////////////////////////////////////
[Name]NewArray
[Title]创建成新数组。
////////////////////////////////////////////////////////////////////////////////
[param]
    <XArray<T> &>srcArray    源数组。
    <int>srcIndex           源数组开始的下标
    <int>copySize       要复制源数组的元素个数
[Exception]
    Exception      如果发生错误，则抛出异常
    EOutOfMemory   如果new出内存失败，则抛出EOutOfMemory异常
[Description]
    从指定的数组中，将自已更新为新的数组,新数组的大小，为指定COPY的大小
    注：如果指定的数组就是当前数组本身，NewArray方法会正常COPY，不会有问题
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
void XArray<T>::NewArray(const XArray<T> & srcArray,int srcIndex,int copySize)//XArray<T> & src,int sPos,int copySize)
{
    //检查越界
    if( copySize < 0) throw Exception("要复制的大小小于零！");
    if(copySize == 0)
    {
        if(m_Data != NULL) {
            delete[] m_Data;
            m_Data = NULL;
        }
        m_Length = 0;
        return;
    }
    if( srcIndex<0 || srcIndex + copySize > srcArray.m_Length ) throw Exception("要复制内容，超出源数组大小！");

    if( &srcArray == this )//如果就是为当前数组对象,则要新申请一块内存
    {
        T * tmp = new T[copySize];

        T * src = srcArray.m_Data + srcIndex;
        T * dest = tmp;
        //打开CodeGuard的时候，这里可能会提示指针计算越界,但实际不会引用越界指针
        for(int i=0; i<copySize; i++)
        {
            *dest =*src;
            dest++;
            src++;
        }
        delete[] m_Data;
        m_Data = tmp;
        m_Length = copySize;
    }
    else//如果不是当前数组对象
    {
        //重定义数据
        if( m_Length < copySize) //如果已有数组容量小于要COPY的容量，则重新申请一块内存
        {
            if(m_Data != NULL) delete[] m_Data;
            m_Data = new T[copySize];
            if(m_Data == NULL) throw EOutOfMemory(EXCEPTION_OUT_OF_MEMORY);
        }
        T * src = srcArray.m_Data + srcIndex;
        T * dest = m_Data;
        //打开CodeGuard的时候，这里可能会提示指针计算越界,但实际不会引用越界指针
        for(int i=0; i<copySize; i++)
        {
            *dest = *src;
            dest++;
            src++;
        }
        m_Length = copySize;
    }
    return;
}
//------------------------------------------------------------------------------
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XDynamicArray
[Title]XDynamicArray<T>的构造函数
////////////////////////////////////////////////////////////////////////////////
[Param]
    <int default=0>InitLength 初始数组的大小
    <int default=0>iPrepareLength 预申请的元素个数
[Exception]
    EOutOfMemory　如果申请内存，则抛出该异常
[Description]
    构造函数,需要指定大小，如果未指定，则默认大小为0
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XDynamicArray<T>::XDynamicArray(int InitLength,int iPrepareLength)
    :m_Data(NULL),m_Length(0)
{
    //每次分配的预分配的个数是16的整数倍
    if( InitLength < 0 ) InitLength = 0;
    if( iPrepareLength < InitLength ) iPrepareLength = InitLength;
    if( iPrepareLength < 16 )  iPrepareLength = 16;
    if( (iPrepareLength % 16) != 0 ) iPrepareLength = iPrepareLength - iPrepareLength % 16 + 16;

    m_Data = new XArray<T>(iPrepareLength);
    if( m_Data == NULL ) throw EOutOfMemory(EXCEPTION_OUT_OF_MEMORY);
    m_Length = InitLength;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XDynamicArray
[Title]XDynamicArray<T>的拷贝构造函数
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XDynamicArray<T> &>srcArray 源数组
[Exception]
    EOutOfMemory 如果申请内存失败，则抛出该异常    
[Description]
    构造拷贝函数
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XDynamicArray<T>::XDynamicArray(const XDynamicArray<T> & srcArray)
    :m_Data(NULL),m_Length(srcArray.m_Length)
{
    m_Data = new XArray<T>( *srcArray.m_Data );
    if( m_Data == NULL ) throw EOutOfMemory(EXCEPTION_OUT_OF_MEMORY);
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XDynamicArray
[Title]XDynamicArray<T>的构造函数
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const XArray<T> &>srcArray 源数组
    <int default=0>iPrepareLength 预申请的元素个数
[Exception]
    EOutOfMemory 如果申请内存失败，则抛出该异常
[Description]
    构造函数,以静态数组为参数
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XDynamicArray<T>::XDynamicArray(const XArray<T> & srcArray,int iPrepareLength)
    :m_Data(NULL),m_Length(0)
{
    int SrcLength = srcArray.GetLength();
    if( iPrepareLength < SrcLength ) iPrepareLength = SrcLength;
    if( iPrepareLength < 16 )  iPrepareLength = 16;
    if( (iPrepareLength % 16) != 0 ) iPrepareLength = iPrepareLength - iPrepareLength % 16 + 16;

    m_Data = new XArray<T>(iPrepareLength);
    if( m_Data == NULL ) throw EOutOfMemory(EXCEPTION_OUT_OF_MEMORY);
    XArray<T>::CopyArray( srcArray, 0, *m_Data, 0, SrcLength);
    m_Length = SrcLength;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]XDynamicArray
[Title]XDynamicArray<T>的构造函数
////////////////////////////////////////////////////////////////////////////////
[Param]
    <const T *> data  指向初始化数据的指针
    <int> InitLength　初始化数据的个数
    <int default=0>iPrepareLength 预申请的元素个数
[Exception]
    EOutOfMemory 如果申请内存失败，则抛出该异常
[Description]
    构造函数,以静态数组为参数
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XDynamicArray<T>::XDynamicArray(const T * data,int InitLength,int iPrepareLength)
{
    if( InitLength < 0 ) InitLength = 0;
    if( iPrepareLength < InitLength ) iPrepareLength = InitLength;
    if( iPrepareLength < 16 )  iPrepareLength = 16;
    if( (iPrepareLength % 16) != 0 ) iPrepareLength = iPrepareLength - iPrepareLength % 16 + 16;

    m_Data = new XArray<T>(iPrepareLength);
    if( m_Data == NULL ) throw EOutOfMemory(EXCEPTION_OUT_OF_MEMORY);
    m_Length = InitLength;

    if( InitLength > 0 )  //如果需要copy data
    {
        T * dest = (T *)m_Data->Data();
        for(int i = 0; i< InitLength; i++)
        {
            *dest = *data;
            dest++;
            data++;
        }
    }
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]expandCapacity
[Title]扩展所需的空间
////////////////////////////////////////////////////////////////////////////////
[param]
    <int>minimumCapacity      所需的最小空间
[Description]
    计算并分配空间
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
void XDynamicArray<T>::expandCapacity(int minimumCapacity)
{
    int newCapacity;
    if( m_Data->GetLength() > 0 ) newCapacity = m_Data->GetLength() * 2;
    else newCapacity = 16;
    if (newCapacity < 0)
    {
          newCapacity = 0x7fffff;//最大32位正整数
    }
    else if (minimumCapacity > newCapacity)
    {
        newCapacity = minimumCapacity;
    }
    //确认分配的元素个数为16的整数倍
    if( (newCapacity % 16) != 0 ) newCapacity = newCapacity - newCapacity % 16 + 16;
    XArray<T> * newArray = new XArray<T>( newCapacity );
    if( m_Length > 0 ) XArray<T>::CopyArray( *m_Data, 0, *newArray, 0, m_Length);
    delete m_Data;
    m_Data = newArray;
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]~XDynamicArray
[Title]XDynamicArray<T>的析构函数
////////////////////////////////////////////////////////////////////////////////
[Description]
    析构函数
[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
XDynamicArray<T>::~XDynamicArray()
{
    delete m_Data;
}

/*
////////////////////////////////////////////////////////////////////////////////
[Name]CopyArray
[Title]复制数组
////////////////////////////////////////////////////////////////////////////////
[param]
    <XDynamicArray<T> &>srcArray       原数组
    <int>srcIndex                   原数组开始的下标
    <XDynamicArray<T> &>destArray   目的数组
    <int>destIndex                  目的数组开始的下标
    <int>copySize                   复制的数组元素
[Exception]
    Exception  如果发生错误，则抛出Exception异常
[Description]
    复制数组的数据，从src复制从srcIndex开始的数据，到dest开始的位置，复制的大小为copySize
    如果发生数据越界，将会抛出异常

[Version]1.0
[Author]Rex Winter
[Date]2005-4-22
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
void XDynamicArray<T>::CopyArray(const XDynamicArray<T> & srcArray,int srcIndex, XDynamicArray<T> & destArray, int destIndex, int copySize)
{
    //检查越界
    if( (destIndex == 0) && (copySize > destArray.m_Length) ) return destArray.NewArray( srcArray, srcIndex, copySize);

    if( copySize < 0 ) throw Exception("要复制的大小小于零！");

    if( (srcIndex < 0) || (srcIndex + copySize > srcArray.m_Length) ) throw Exception("要复制内容，超出源数组大小！");

    if( destIndex < 0 ) throw Exception("要复制内容，越出目的数组大小！");

    destArray.ensureCapacity( destIndex + copySize ); //确定最小要的空间
    XArray<T>::CopyArray( *srcArray.m_Data, srcIndex, *destArray.m_Data, destIndex, copySize);
    if( (destIndex + copySize) > destArray.m_Length ) destArray.m_Length = destIndex + copySize;
}

/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator []
[Title]取得数组元素。
////////////////////////////////////////////////////////////////////////////////
[param]
    <int>Index    对应的数组的下标
[Return]
    <T&>返回数组元素的引用。
[Exception]
    XExceptionArrayOutOfRange  如果下标越界，则抛出XExceptionArrayOutOfRange异常
[Description]
    取得数组元素，并返回这个元素的引用。
[Version]1.0
[Author]Rex Winter
[Date]2005-4-26
////////////////////////////////////////////////////////////////////////////////
*/
template<class T>
T & XDynamicArray<T>::operator[](int Index)
{
    if( Index<0 || Index >= m_Length ) throw XExceptionArrayOutOfRange(Index, m_Length);
    return m_Data->operator[](Index);
}
/*
////////////////////////////////////////////////////////////////////////////////
[Name]operator [] const
[Title]取得数组元素。
////////////////////////////////////////////////////////////////////////////////
[param]
    <int>Index    对应的数组的下标
[Return]
    <const T&>返回数组元素的引用。但这个返回值不能修改的
[Exception]
    XExceptionArrayOutOfRange  如果下标越界，则抛出XExceptionArrayOutOfRange异常
[Description]
    取得数组元素，并返回这个元素的引用。
    这个方法，注明为const类型，表示为不可修改。
[Version]1.0
[Author]Rex Winter
[Date]2005-4-26
////////////////////////////////////////////////////////////////////////////////
*/