数据结构中数组的顺序存储

#include<iostream>
#include<cstdarg>
using namespace std;

//--------------------数组的顺序存储表示--------------------
#define MAX_ARRAY_DIM 8
#define error -1
#define ok 1
typedef int ElemType;
typedef int Status;
typedef char* va_list;
typedef struct{
	ElemType	*base;	//数组元素基址,由InitArray分配
	int			dim;	//数组维数
	int			*bound;	//数组维界基址,由InitArray分配
	int			*constants;	//数组映像函数常量基址，由InitArray分配
}Array;

//-------------------基本操作的函数原型说明-------------------
class ArrayOperation{
public:
	//若维数dim和随后的各维长度合法，则构造相应的数组A，并返回ok
	Status InitArray(Array &A,int dim,...);
	//销毁数组A
	Status DesArray(Array &A);
	//若ap指向的各下标值合法，则求出该元素在A中的相对地址off
	Status Locate(Array A,va_list ap,int &off);
	//A是n维数组，e为元素变量，随后是n个下标值
	//若各下标不超界，则e赋值为所指定的A的元素之，并返回ok
	Status Value(Array A,ElemType &e,int n,...);
	//A是n维数组，e为元素变量，随后是n个下标值
	//若各下标不超界，则将e的值赋给指定的A的元素，并返回ok
	Status Assign(Array &A,ElemType e,int n,...);
};

//--------------------基本操作的函数实现-----------------------
Status ArrayOperation::InitArray(Array &A,int dim,...)
{
	int elemtotal=1;	//定义A的元素总数
	va_list	ap;
	if(1>dim||MAX_ARRAY_DIM<dim)
		return error;
	A.dim=dim;	//数组A的维数
	A.bound=new int[dim];//分配数组维界的内存空间
	if(!A.bound)
		exit(-1);
	//若各维长度合法，则存入A.bounds，并求出A的元素总和elemtotal
	va_start(ap,dim); 	//ap是存放变长参数表信息的数组
	for(int i=0;i<dim;i++)
	{
		A.bound[i]=va_arg(ap,int);	//	确定各维长度
		if(A.bound[i]<0)
			return error;
		elemtotal*=A.bound[i];	//矩阵A的元素总数
	}//for
	va_end(ap);
	A.base=new ElemType[elemtotal];//分配矩阵A的内存空间
	if(!A.base)
		exit(-1);
	//求映像函数的常数Ci，并存入A.constants[i-1],i=1,2,...dim
	A.constants=new int[dim];
	if(!A.constants)
		exit(-1);
	A.constants[dim-1]=1;	//L=1，指针的增减以元素的大小为单位
	for(int i=dim-2;i>=0;i--)
		A.constants[i]=A.bound[i+1]*A.constants[i+1];
	return ok;
}//InitArray

Status ArrayOperation::DesArray(Array &A)
{
	if(!A.base||!A.bound||!A.constants)
		return error;
	delete A.base;	A.base=NULL;
	delete A.bound;	A.bound=NULL;
	delete A.constants;	A.constants=NULL;
	return ok;
}//DesArray

Status ArrayOperation::Locate(Array A,va_list ap,int &off)
{
	int loc;
	off=0;
	for(int i=0;i<A.dim;i++)
	{
		loc=va_arg(ap,int);
		if(loc<0||loc>=A.bound[i])//每一维的下标应小于该维的长度
			return error;
		off+=A.constants[i]*loc;
	}//for
	return ok;
}//Locate

Status ArrayOperation::Value(Array A,ElemType &e,int n,...)
{
	va_list ap;
	int off=0;
	va_start(ap,n);
	if(!Locate(A,ap,off))
		return error;
	e=*(A.base+off);	//将合法的下标值赋给e
	return ok;
}//Value

Status ArrayOperation::Assign(Array &A,ElemType e,int n,...)
{
	va_list ap;
	int off=0;
	va_start(ap,n);
	if(!Locate(A,ap,off))
		return error;
	*(A.base+off)=e;
	return ok;
}//Assign

void main()
{
	ArrayOperation	AOP;
	Array	A;
	int i,j;
	ElemType e=0;
	AOP.InitArray(A,2,2,2);
	for(i=0;i<2;i++)
		for(j=0;j<2;j++)
				AOP.Assign(A,++e,2,i,j);
	for(i=0;i<2;i++)
	{
		for(j=0;j<2;j++)
		{
				AOP.Value(A,e,2,i,j);
				cout<<e<<" ";
		}//for
		cout<<endl;
	}//for			
}//main