====== template <typename T> XArray ======

**//Inherited from//**  NULL

**//Inherited by//**  NULL

**//Friend class//**  NULL

**//Description//**

XArray是一个封装了数组功能的模板类，主要用于数据对象里需要保存变长数据的场合，对数据对象的任何修改即意味着变长数组的重建（当数组长度变化时）。与标准库里面的vector不一样，它不太适用于可以随时添加元素的场景，但是另一方面它也有效降低了该类的复杂度，开发者要根据实际情况觉得是否使用XArray类。

**//Members//**
  * size_t [[xarray#m_size|m_Size]]
  * T * [[xarray#m_pvec|m_pVec]]
**//Public interface//**
  * [[xarray#xarray1|XArray]](int size = 0)
  * const T * [[xarray#end|end]]() const
  * XArray<T> & operator [[xarray#copy|=]] (const XArray<T> &r)
  * [[xarray#xarray2|XArray]](const [[xarray#xarray2|XArray]]<T> & r)
  * [[xarray#~xarray|~XArray]]()
  * void [[xarray#release|release]]()
  * void [[xarray#alloc|alloc]]()
  * void [[xarray#remove|remove]](int i)
  * int [[xarray#size|size]]() const
  * T & [[xarray#front|front]]()
  * T & [[xarray#back|back]]()
  * const T & [[xarray#front|front]]() const
  * const T & [[xarray#back|back]]() const
  * void [[xarray#resize|resize]](int size, bool bCopyFromOld = false)
  * T * [[xarray#data|data]]()
  * const T * [[xarray#data|data]]() const
  * operator T [[xarray#*|*]]() const
  * T& operator [[xarray#at|[]]](int index)
  * const T& operator [[xarray#at|[]]](int index) const
  * T& [[xarray#at|at]](int index)
  * const T& [[xarray#at|at]](int index) const
  * void [[xarray#assign|assign]](const XArray<T> & r)
  * void [[xarray#append|append]](const XArray<T> & r)
  * void [[xarray#assign|assign]](const T * pSrc, int size)
  * void [[xarray#insert|insert]](int index, const T & item)
  * XArray<T> & operator [[xarray#copy|=]] (const vector<T> & vec)

----

{{anchor:m_size}}
**size_t m_Size**

数组长度

{{anchor:m_pvec}}
**T * m_pVec**

数组首地址

----

{{anchor:xarray1}}
**XArray(int size = 0) **
  *function: 构造函数
  *parameters: 
    - [i]int size = 0: 数组大小，默认情况下为0，数组不分配内存
  *return value: 无

{{anchor:end}}
**const T * end() const**
  *function: 获取数组的末地址，一般用于判断给定元素是否到达数组尾部
  *parameters: NULL
  *return value: 无

{{anchor:copy}}
**XArray<T> & operator = (const XArray<T> &r)**
  *function: 赋值构造函数
  *parameters: 
    - [i]const XArray<T> &r: 另一个数组对象
  *return value: 数组对象的引用

{{anchor:xarray2}}
**XArray(const XArray<T> & r) **
  *function: 复制构造函数
  *parameters: 
    - [i]const [[xarray#xarray2|XArray]]<T> & r: 另一个数组对象
  *return value: 无

{{anchor:~xarray}}
**~XArray()**
  *function: 析构函数，释放内存
  *parameters: NULL
  *return value: 无

{{anchor:release}}
**void release()**
  *function: 释放数组内存
  *parameters: NULL
  *return value: 无

{{anchor:alloc}}
**void alloc()**
  *function: 为数组分配内存空间
  *parameters: NULL
  *return value: 无

{{anchor:remove}}
**void remove(int i)**
  *function: 删除第i个元素
  *parameters: 
    - [i]int i: 元素序号
  *return value: 无

{{anchor:size}}
**int size() const**
  *function: 获取数组长度
  *parameters: NULL
  *return value: 数组长度

{{anchor:front}}
**T & front()**
  *function: 获取数组的第一个元素
  *parameters: NULL
  *return value: 数组第一个元素的引用，可以修改

{{anchor:back}}
**T & back()**
  *function: 获取数组的最后一个元素，可以修改
  *parameters: NULL
  *return value: 最后一个元素的引用

{{anchor:front}}
**const T & front() const**
  *function: 获取数组的第一个元素，不能修改
  *parameters: NULL
  *return value: 数组第一个元素的常引用

{{anchor:back}}
**const T & back() const**
  *function: 获取数组的最后一个元素，不能修改
  *parameters: NULL
  *return value: 数组最后一个元素的常引用

{{anchor:resize}}
**void resize(int size, bool bCopyFromOld = false)**
  *function: 修改数组长度，根据需要拷贝旧的数据（最大只拷贝size范围内的数据）
  *parameters: 
    - [i]int size: 新的数组长度
    - [i] bool bCopyFromOld = false: 若需要拷贝旧的数据为true，否则为false
  *return value: 无

{{anchor:data}}
**T * data()**
  *function: 获取数组地址
  *parameters: NULL
  *return value: 数组地址 

{{anchor:data}}
**const T * data() const**
  *function: 获取数组地址
  *parameters: NULL
  *return value: 数组地址

{{anchor:*}}
**operator T *() const**
  *function: 转换为数组地址
  *parameters: NULL
  *return value: 数组地址

{{anchor:at}}
**T& operator [](int index)**
  *function: 访问第index个元素
  *parameters: 
    - [i]int index: 元素的位置索引
  *return value: 第index个元素的引用

{{anchor:at}}
**const T& operator [](int index) const**
  *function: 访问第index个元素（不能修改）
  *parameters: 
    - [i]int index: 元素的位置索引
  *return value: 第index个元素的常引用

{{anchor:at}}
**T& at(int index)**
  *function: 访问第index个元素（可以修改）
  *parameters: 
    - [i]int index: 元素的位置索引
  *return value: 第index个元素的常引用

{{anchor:at}}
**const T& at(int index) const**
  *function: 访问第index个元素（不能修改）
  *parameters: 
    - [i]int index: 元素的位置索引
  *return value: 第index个元素的常引用

{{anchor:assign}}
**void assign(const XArray<T> & r)**
  *function: 将另一个数组赋值到本数组（和复制构造函数类似）
  *parameters: 
    - [i]const XArray<T> & r: 赋值源数组对象
  *return value: 无

{{anchor:append}}
**void append(const XArray<T> & r)**
  *function: 将另一个数组添加到本数组尾部（本数组会重新分配空间以容纳所有元素）
  *parameters: 
    - [i]const XArray<T> & r: 添加源数组对象
  *return value: 无

{{anchor:assign}}
**void assign(const T * pSrc, int size)**
  *function: 从另一个数组赋值到本数组
  *parameters: 
    - [i]const T * pSrc: 源数组地址
    - [i] int size: 源数组长度
  *return value: 无

{{anchor:insert}}
**void insert(int index, const T & item)**
  *function: 在第index个位置插入元素
  *parameters: 
    - [i]int index: 插入位置
    - [i] const T & item: 代插入的元素
  *return value: 无

{{anchor:copy}}
**XArray<T> & operator = (const vector<T> & vec)**
  *function: 从标准库的vector赋值到本数组
  *parameters: 
    - [i]const vector<T> & vec: 标准库源数组
  *return value: 本数组的引用