多維數組的順序表示

多維數組節點，有四個元素
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. */
6. #include <stdio.h>
7. #include <stdarg.h>
8. #include <stdlib.h>
9. #include <malloc.h>
11. #define OK 1
12. #define ERROR 0
13. #define MAX_ARRAY_DIM 8
15. typedef struct
16. {
17. int *base; //數組的基地址，初始化時分配
18. int dim; //數組的維數
19. int *bounds; //數組每一維的長度
20. int *constants; //數組映象函數常量基址
22. }array;
24. int init_array(array *a, int dim, ...)
25. {
26. int i = 0;
27. int elem_num = 1; //記錄數組中元素的個數
28. va_list ap = NULL;
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. }
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);
53. a->base = (int *)malloc(elem_num * sizeof(int));
54. if(! (a->base))
55. {
56. return ERROR;
57. }
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. }
70. return OK;
71. }
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;
83. if(a->bounds)
84. {
85. free(a->bounds);
86. a->bounds = NULL;
87. }
88. else
89. return ERROR;
91. if(a->constants)
92. {
93. free(a->constants);
94. a->constants = NULL;
95. }
96. else
97. return ERROR;
99. return OK;
100. }
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;
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. }
118. return OK;
119. }
121. int get_array_elem(int *e, array a, ...)
122. {
123. va_list ap;
124. int result = 0;
125. int offset = 0;
127. va_start(ap, a);
128. if(!(result = locate_array_elem(a, ap, &offset)))
129. {
130. return ERROR;
131. }
132. va_end(ap);
134. *e = *(a.base + offset);
136. return OK;
137. }
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);
151. *(a->base + offset) = e;
153. return OK;
154. }
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;
167. init_array(&arr, dim, bound1, bound2, bound3);
169. printf("array.bounds = "); //順序輸出array.bounds
170. p = arr.bounds;
171. for(i = 0; i < dim; i++)
172. {
173. printf("%d ", *(p + i));
174. }
176. printf("\narray.contents = "); //順序輸出array.contents
177. p = arr.constants;
178. for(i = 0; i < dim; i++)
179. {
180. printf("%d ", *(p + i));
181. }
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. }
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. }
210. destory_array(&arr);
212. return 0;
213. }