一、数组的定义
几乎所有的程序设计语言都把数组类型设定为固有类型。
以抽象数据类型的形式讨论数组的定义和实现,可以让我们加深对数组类型的理解。
数组的定义:
ADT Array{
数据对象:ji=0,...,bi-1,i=1,2,...,n;
D={aj1j2...jn|n(>0)称为数组的维数,bi是数组第i维的长度,ji是数组元素的第i维下标,aj1j2...jn (-ElemSet}
数据关系:R={R1,R2,...Rn|
Ri={<aj1...ji...jn,aj1...ji+1 ...jn>|
0<=jk<=bk-1,1<=k<=n且k<>i,
0<=ji<=bi-2,aj1...ji...jn,
aj1...ji+1 ...jn(-D,i=2,...n}
基本操作:
InitArray(&A,n,bound1,...,boundn)
若维数和各维长度合法,则构造相应的数组A,并返回OK.
DestroyArray(&A)
操作结果:销毁数组A.
Value(A,&e,index1,...,indexn)
初始条件:A是n维数组,e为元素变量,随后是n个下标值.
操作结果:若各下标不超界,则e赋值为所指定的A的元素值,并返回OK.
Assign(&A,e,index1,...,indexn)
初始条件:A是n维数组,e为元素变量,随后是n个下标值.
操作结果:若下标不超界,则将e的值赋给 所指定的A的元素,并返回OK.
}ADT Array
![奋斗](http://static.blog.csdn.net/xheditor/xheditor_emot/default/struggle.gif)
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#define MAX_ARRAY_DIM 8
typedef struct {
int dim; // 维数, 比如2维数组, 3维数组
int *base; // 数组的基地址, 任一维的形式在内存中都作为一维存储, 线性排列
int *bounds; // 数组维界基址, 记录每维大小
int *constants;// 数组映象函数常量基址, 用于定位元素使用
}array_st;
int elem_total; // 计算元素总个数, 申请连续内存
int init_array(array_st *array, int dim, ...)
{
int i;
va_list ap;//变长参数,在stdarg.h中
if(dim < 1 || dim > MAX_ARRAY_DIM)
return -1;
array->dim = dim;
array->bounds = (int *)malloc(dim * sizeof(int));
if(!array->bounds)
return -1;
elem_total = 1;
va_start(ap, dim);//意思大概是ap这个变长参数的地址从dim后面开始
for(i = 0; i < dim; i++) {
array->bounds[i] = va_arg(ap, int);//逐一为bounds[i]赋值
if(array->bounds[i] < 0)
return -1;
elem_total *= array->bounds[i]; // n维数组, 每维数目的乘积, 如[2][3] = 2*3 = 6个元素
}
va_end(ap);//结束提取变长参数
array->base = (int *)malloc(elem_total * sizeof(int)); //一大块连续内存存放多维数组的内容
if(!array->base)
return -1;
for(i = 0; i < elem_total; i++) { // 测试用的初始化
array->base[i] = i;
}
array->constants = (int *)malloc(dim * sizeof(int));
// constants辅助进行元素定位, 记录每一维需要增加时需要跨越的元素个数.
// 如: [2][3], 取[1][2]时, 需要跨越[0][0]~[0][2], [1][0],[1][1]然后取到[1][2], 第1维需要增加是需要跨越
// [0][0],[0][1],[0][2]三个元素
if(!array->constants)
return -1;
array->constants[dim - 1] = 1;
for(i = dim - 2; i >= 0; --i) {
array->constants[i] = array->bounds[i+1] * array->constants[i+1];
// 当前维移动时, 跨越的元素个数为下一维元素个数 与 下一维移动时需要跨越的元素个数
// 不太好理解, 可以看上面的array[2][3]的例子:
// 第二维移动时, 只需要跨越1个元素, 比如[0][0]到[0][1]
// 第一维移动时, 如[0][0]到[1][0], 一定会经历[0][0], [0][1], [0][2], 三个元素, 下一个才是[1][0]
// 计算为3(第二维元素个数) * 1(第二维移动时需要跨越的元素个数)
}
return 0;
}
int locate(array_st *array, va_list ap, int *offset)
{
int i, ind;
*offset = 0;
for(i = 0; i < array->dim; i++) {
ind = va_arg(ap, int);
if(ind < 0 || ind > array->bounds[i])
return -1;
*offset += array->constants[i] * ind;
}
return 0;
}
int assign(array_st *array, int value, ...)
{
va_list ap;
int offset;
va_start(ap, value);
if(locate(array, ap, &offset) < 0)
return -1;
*(array->base + offset) = value;
return 0;
}
int main()
{
int i;
array_st array;
init_array(&array, 2, 2, 3);
for(i = 0; i < elem_total; i++) {
printf("array[%d]:%d\n", i, array.base[i]);
}
printf("---------------------------------------------------\n");
assign(&array, 100, 0, 1);
for(i = 0; i < elem_total; i++) {
printf("array[%d]:%d\n", i, array.base[i]);
}
return 0;
}
![奋斗](http://static.blog.csdn.net/xheditor/xheditor_emot/default/struggle.gif)
#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )
#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //第一个可选参数地址
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址
#define va_end(ap) ( ap = (va_list)0 ) // 将指针置为无效