多維數組的順序表示

多維數組節點，有四個元素
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. }