多维数组的顺序表示


多维数组节点，有四个元素
struct array
{
        int *base;            //存放数组的元素的基地址
        int dim;              //表示多维数组的维数
        int *bounds;      //表示每一维的长度
        int *constants;  //存放数组映象函数常量基址

}; 

譬如一个2*3的二维数组，dim就等于二，行优先存储，bounds[0]就为2，bounds[1]就为3。

对于constants，constant[i]就是第i+1层的数组中每一元素(数组)的大小。
对于行主序的2*3的二维数组来说，constant[1]就是每一行的一个元素(如:((a,b,c),(d,e,f))中a,f)占据的内存长度
constant[0]就是当前行每一列(如:(A,B),其中A=(a,b,c),B=(d,e,f)),A、B占据的内存长度。

  1. /* 
  2. 多维数组的顺序表示 
  3. 调试环境：vs2010,gcc 
  4. */ 
  5.  
  6. #include <stdio.h>  
  7. #include <stdarg.h>  
  8. #include <stdlib.h>  
  9. #include <malloc.h>  
  10.  
  11. #define OK      1  
  12. #define ERROR   0  
  13. #define MAX_ARRAY_DIM 8  
  14.  
  15. typedef struct   
  16. { 
  17.     int *base;      //数组的基地址，初始化时分配  
  18.     int dim;            //数组的维数  
  19.     int *bounds;        //数组每一维的长度  
  20.     int *constants; //数组映象函数常量基址  
  21.  
  22. }array; 
  23.  
  24. int init_array(array *a, int dim, ...) 
  25. { 
  26.     int i = 0; 
  27.     int elem_num = 1;       //记录数组中元素的个数  
  28.     va_list ap = NULL; 
  29.  
  30.     if(dim < 1 || dim > MAX_ARRAY_DIM) 
  31.     { 
  32.         return ERROR; 
  33.     } 
  34.     a->dim = dim; 
  35.     a->bounds = (int *)malloc(dim * sizeof(int)); 
  36.     if(!(a->bounds)) 
  37.     { 
  38.         return ERROR; 
  39.     } 
  40.  
  41.     va_start(ap, dim); 
  42.     for(i = 0; i < dim; i++) 
  43.     { 
  44.         a->bounds[i] = va_arg(ap, int); 
  45.         if(a->bounds[i] < 0) 
  46.         { 
  47.             return ERROR; 
  48.         } 
  49.         elem_num *= a->bounds[i]; 
  50.     } 
  51.     va_end(ap); 
  52.  
  53.     a->base = (int *)malloc(elem_num * sizeof(int)); 
  54.     if(! (a->base)) 
  55.     { 
  56.         return ERROR; 
  57.     } 
  58.  
  59.     a->constants = (int *)malloc(dim * sizeof(int)); 
  60.     if(!(a->constants)) 
  61.     { 
  62.         return ERROR; 
  63.     } 
  64.     a->constants[dim - 1] = 1; 
  65.     for(i=dim-2; i>=0; i--) 
  66.     { 
  67.         a->constants[i] = a->constants[i+1] * a->bounds[i+1];   
  68.     } 
  69.  
  70.     return OK; 
  71. } 
  72.  
  73. int destory_array(array *a) 
  74. { 
  75.     if(a->base) 
  76.     { 
  77.         free(a->base); 
  78.         a->base = NULL; 
  79.     } 
  80.     else 
  81.         return ERROR; 
  82.  
  83.     if(a->bounds) 
  84.     { 
  85.         free(a->bounds); 
  86.         a->bounds = NULL; 
  87.     } 
  88.     else 
  89.         return ERROR; 
  90.  
  91.     if(a->constants) 
  92.     { 
  93.         free(a->constants); 
  94.         a->constants = NULL; 
  95.     } 
  96.     else 
  97.         return ERROR; 
  98.  
  99.     return OK; 
  100. } 
  101.  
  102. /*寻找待搜索的arr[i][j][k]相对于基地址的偏移量*/ 
  103. int locate_array_elem(array a, va_list ap, int *offset) 
  104. { 
  105.     int i = 0; 
  106.     int curdim = 0; 
  107.  
  108.     for(i = 0; i < a.dim; i++) 
  109.     { 
  110.         curdim = va_arg(ap, int); 
  111.         if(curdim < 0 || curdim >=a.bounds[i]) 
  112.         { 
  113.             return ERROR; 
  114.         } 
  115.         *offset += a.constants[i] * curdim; 
  116.     } 
  117.  
  118.     return OK; 
  119. } 
  120.  
  121. int get_array_elem(int *e, array a, ...) 
  122. { 
  123.     va_list ap; 
  124.     int result = 0; 
  125.     int offset = 0; 
  126.      
  127.     va_start(ap, a); 
  128.     if(!(result = locate_array_elem(a, ap, &offset))) 
  129.     { 
  130.         return ERROR; 
  131.     } 
  132.     va_end(ap); 
  133.  
  134.     *e = *(a.base + offset); 
  135.  
  136.     return OK; 
  137. } 
  138.  
  139. int assign_array_elem(int e, array *a, ...) 
  140. { 
  141.     va_list ap; 
  142.     int result = 0; 
  143.     int offset = 0; 
  144.     va_start(ap, a); 
  145.     if(!(result = locate_array_elem(*a, ap, &offset))) 
  146.     { 
  147.         return ERROR; 
  148.     } 
  149.     va_end(ap); 
  150.      
  151.     *(a->base + offset) = e; 
  152.  
  153.     return OK; 
  154. } 
  155.  
  156.  
  157. int main(int argc, char *argv[]) 
  158. { 
  159.     array arr; 
  160.     int dim = 3; 
  161.     int bound1 = 2, bound2 = 3, bound3 = 4; //arr[2][3][4]数组  
  162.     int i = 0, j = 0, k = 0; 
  163.     int assign_elem = 0; 
  164.     int get_elem = 0; 
  165.     int *p = NULL; 
  166.  
  167.     init_array(&arr, dim, bound1, bound2, bound3); 
  168.  
  169.     printf("array.bounds = ");          //顺序输出array.bounds  
  170.     p = arr.bounds; 
  171.     for(i = 0; i < dim; i++) 
  172.     { 
  173.         printf("%d ", *(p + i)); 
  174.     } 
  175.  
  176.     printf("\narray.contents = ");      //顺序输出array.contents  
  177.     p = arr.constants; 
  178.     for(i = 0; i < dim; i++) 
  179.     { 
  180.         printf("%d ", *(p + i)); 
  181.     } 
  182.  
  183.     printf("\narray[%d][%d][%d] : \n", bound1, bound2, bound3); 
  184.     for(i = 0; i < bound1; i++) 
  185.     { 
  186.         for(j = 0; j < bound2; j++) 
  187.         { 
  188.             for(k = 0; k < bound3; k++) 
  189.             { 
  190.                 assign_elem = i * 100 + j * 10 + k; 
  191.                 assign_array_elem(assign_elem, &arr, i, j, k); 
  192.                 get_array_elem(&get_elem, arr, i, j, k); 
  193.                 printf("array[%d][%d][%d]=%-4d", i, j, k, get_elem); 
  194.             } 
  195.             printf("\n"); 
  196.         } 
  197.         printf("\n"); 
  198.     } 
  199.  
  200.     p = arr.base; 
  201.     for(i = 0; i < bound1 * bound2 * bound3; i++) 
  202.     { 
  203.         printf("%-4d", *(p + i)); 
  204.         if(i % (bound2 * bound3) == bound2 * bound3 - 1) 
  205.         { 
  206.             printf("\n"); 
  207.         } 
  208.     } 
  209.  
  210.     destory_array(&arr); 
  211.      
  212.     return 0; 
  213. } 

相关内容