数组的顺序存储

/*#include<stdarg.h>用于获取不确定个数的参数

  数据类型：va_list：用于保存va_arg、va_end所需的信息

  提供宏va_start：使va_list指向起始的参数
        va_arg：检索参数
        va_end：释放va_list
*/
#include<bits/stdc++.h>
#define Max_ARRAY_DIM  8 ///假设数组维数最大为8
#define ERROR 0
#define OK 1
#define UNDERFLOW -2
#define OVERFLOW 1
using namespace std;

typedef int Status;
typedef int elemtype;

typedef struct
{
    elemtype *base; /// 数组元素的基址，由Init分配
    int dim;         ///数组维数
    int *bounds;    ///数组维界基址，由Init分配
    int *constants; ///数组映像函数常量基址，由Init分配
}Array;

///若维数 n 和各维长度合法，则构造相应的数组A，并返回OK
Status Init(Array &A, int dim,...)
{
    if(dim < 1 || dim >  Max_ARRAY_DIM)
        return ERROR;
    A.dim = dim;
    A.bounds = (int *)malloc(dim * sizeof(int));
    if(!A.bounds)
        exit(OVERFLOW);
    ///若各维长度合法，则存入A.bounds,并求出A的元素总数elemtotal
    va_list ap;
    int i,elemtotal = 1;
    va_start(ap,dim);   ///ap为va_list类型，是存放变长参数表信息的数组
    for(i = 0; i < dim ; i++)
    {
        A.bounds[i] = va_arg(ap,int);
        //printf("A.bounds[%d]------%d\n",i,A.bounds[i]);
        if(A.bounds[i] < 0)
            return UNDERFLOW;
            /*
                underflow 堆栈下溢，常赋值为负数
                原因：指针调用错误、系统栈空间过小、指针被错误修改
            */
        elemtotal *= A.bounds[i];
    }
    va_end(ap);

    A.base = (elemtype*)malloc(elemtotal * sizeof(elemtype));
    if(!A.base)
        exit(OVERFLOW);
    ///求映像函数的常数Ci，并存入A.constants[i-1],i = 1.....dim
    A.constants = (int *)malloc(dim * sizeof(int));
    if(!A.constants)
        exit(OVERFLOW);
    A.constants[dim - 1] = 1; ///L = 1，指针的增减以元素的大小为单位
    for(i = dim - 2; i>=0; i--){
        A.constants[i] = A.bounds[i+1] * A.constants[i+1];
    }
    return OK;
}
///销毁数组
Status DestroyArray(Array &A)
{
    if(!A.base)
        return ERROR;
    free(A.base);
    A.base = NULL;

    if (!A.bounds)
        return ERROR;
    free(A.bounds);
    A.bounds = NULL;

    if (!A.constants)
        return ERROR;
    free(A.constants);
    A.constants = NULL;
    return OK;
}


///若ap指示的各下标值合法，则求出该元素在A中相当地址off
Status Locate(Array A, va_list ap, int &off)
{
    off = 0;
    int i, ind;
    for(i = 0; i < A.dim; i++)
    {
        ind  = va_arg(ap,int);
        if(ind < 0 || ind >= A.bounds[i])
            return OVERFLOW;
        off += A.constants[i]*ind;
    }
    return OK;
}
/*
A是n维数组，e为元素变量，后面是n 个下标值。
若各下标不超界，则e被赋值为所指定的A的元素值，并返回OK。
e=A[i1][i2]…[in];
*/
Status Value(Array A,elemtype &e,...)
{
    va_list ap;
    int off,result;
    va_start(ap,e);
    if((result = Locate(A,ap,off)) <= 0)
        return result;
    e = *(A.base + off);
    return OK;
}

/*
A是n维数组，e为元素变量，随后是n 个下标值。
若下标不超界，则将e的值赋给所指定的A的元素，并返回OK。
A[i1][i2]…[in] =e;
*/
Status Assign(Array &A, elemtype e,...)
{
    va_list ap;
    int result , off;
    va_start(ap,e);
    if((result = Locate(A,ap,off)) <= 0)
        return result;
    *(A.base + off) = e;
    return OK;
}

int main()
{
    Array a;
    int i,j,m,n;
    elemtype x;
    cin>>m>>n;
    Init(a,2,m,n);
    for(i=0;i<m;i++)
        for (j=0;j<n;j++)
            Assign(a,(i+1)*(j+1),i,j);
    for(i=0;i<m;i++)
    {
        for (j=0;j<n;j++)
        {
            Value(a,x,i,j);
            cout<<"   "<<x;
        }
        if( i != m - 1)
            cout<<‘\n‘;
    }
    return 0;
}