/**

 * @brief C语言 数组 行优先 实现

 * @author wid

 * @date 2013-11-02

 *

 * @note 若代码存在 bug 或程序缺陷, 请留言反馈, 谢谢!

 */

 #include <stdio.h>

 #include <stdlib.h>

 #include <stdarg.h>

 #include <assert.h>

 #define OK 1

 #define ERROR -1

 #define MAX_DIM 8       ///允许的最大数组维数

 typedef int ElemType;

 typedef struct

 {

     ElemType *base;         ///数组元素基址

     int dim;                ///数组维数

     int *bounds;            ///数组维界基址

     int *constants;         ///数组映像函数常量基址

 }Array;     ///数组结构

 ///数组方法声明

 int InitArray( Array *pArr, int nDim, ... );        ///初始化数组 pArr

 void DestroyArray( Array *pArr );                   ///销毁数组 pArr

 int Locate( Array *pArr, int nDim, va_list ap );                     ///定位下标指向的元素在数组中的位置

 int Assign( Array *pArr, ElemType *elm, ... );      ///数组赋值

 int Value( Array *pArr, ElemType *elm, ... );       ///数组取值

 ///数组方法实现

 /**

 * @brief 初始化数组

 *

 * @param pArr 指向待初始化的数组

 * @param nDim 数组的维数

 * @param ... 数组各维数的长度

 *

 * @return 初始化成功返回OK, 否则返回ERROR

 */

 int InitArray( Array *pArr, int nDim, ... )

 {

     if( nDim <  || nDim > MAX_DIM )

         return ERROR;

     ///初始化 pArr 数组维数属性

     pArr->dim = nDim;

     ///构造数组维界基址

     pArr->bounds = (int *)malloc( nDim * sizeof(int) );

     if( !pArr->bounds )

         return ERROR;

     int i = , nElemCount = ;

     va_list ap;

     va_start( ap, nDim );

     for( i = ; i < nDim; ++i )

     {

         pArr->bounds[i] = va_arg( ap, int );

         if( pArr->bounds[i] <  )

             return ERROR;

         nElemCount *= pArr->bounds[i];

     }

     va_end(ap);

     ///初始化元素基址

     pArr->base = (ElemType *)malloc( nElemCount * sizeof(ElemType) );

     if( !pArr->base )

         return ERROR;

     ///初始化函数映像常数基址

     pArr->constants = (int *)malloc( nDim * sizeof(int) );

     ///递推求常量基址

     pArr->constants[nDim-] = ;

     for( i = nDim - ; i >= ; --i )

     {

         pArr->constants[i] = pArr->bounds[i+] * pArr->constants[i+];

     }

     return OK;

 }

 /**

 * @brief 销毁数组 pArr

 *

 * @param pArr 指向待销毁的数组

 */

 void DestroyArray( Array *pArr )

 {

     if( pArr->base )

         free( pArr->base );

     if( pArr->bounds )

         free( pArr->bounds );

     if( pArr->constants )

         free( pArr->constants );

 }

 /**

 * @brief 定位数组下标指向的元素在数组中的位置

 *

 * @param 指向的数组

 * @param ... 数组的下标

 *

 * @return 若下标合法, 返回下标在数组中的位置, 否则返回 ERROR

 */

 int Locate( Array *pArr, int nDim, va_list ap )

 {

     int nPos = , ind = , i = ;

     for( i = ; i < pArr->dim; ++i )

     {

         ind = va_arg( ap, int );

         ///使用断言, 确保下标合法

         assert( ind >=  && ind < pArr->bounds[i] );

         nPos += pArr->constants[i] * ind;

     }

     va_end(ap);

     return nPos;

 }

 /**

 * @brief 数组赋值

 *

 * @param pArr 指向待赋值的数组

 * @param elm 指向赋值元素

 * @param nDim 数组维数

 * @param ... 数组下标

 *

 * @param 赋值成功返回 OK, 否则返回 ERROR

 */

 int Assign( Array *pArr, ElemType *elm, ... )

 {

     int nPos = ;

     va_list ap;

     va_start( ap, elm );

     nPos = Locate( pArr, pArr->dim, ap );

     *(pArr->base + nPos) = *elm;

     return OK;

 }

 /**

 * @brief 数组取值

 */

 int Value( Array *pArr, ElemType *elm, ... )

 {

     int nPos = ;

     va_list ap;

     va_start( ap, elm );

     nPos = Locate( pArr, pArr->dim, ap );

     *elm = *(pArr->base + nPos);

     return OK;

 }

 //测试

 int main()

 {

     Array arr;

     ///初始化一个三维数组, 大小为 2x3x5

     InitArray( &arr, , , ,  );

     int a = ;

     ///赋值测试

     int i = , m = , n = ;

     for( i = ; i < ; ++i )

         for( m = ; m < ; ++m )

             for( n = ; n < ; ++n )

             {

                 a = i + m + n;

                 Assign( &arr, &a, i, m, n );

             }

     int b = ;

     ///取值测试

     for( i = ; i < ; ++i )

         for( m = ; m < ; ++m )

             for( n = ; n < ; ++n )

             {

                  Value( &arr, &b, i, m, n );

                  printf( "[%d][%d][%d]=%d\n", i, m, n, b );

             }

     ///销毁数组

     DestroyArray( &arr );

     return ;

 }