数组

数组的定义：

数组: 由一组名字相同､下标不同的n(n≥1)个相同数据类型的数据元素a0,a1,a2,…,an-1构成的占用一块地址连续的内存单元的有限集合。

数组的特点：

• 数组中各元素具有统一的类型;
• 数组元素的下标一般具有固定的上界和下界,即数组一旦被定义,它的维数和维界就不再改变｡
• 数组的基本操作比较简单,除了结构的初始化和销毁之外,只有存取元素和修改元素值的操作｡

有关stdarg.h头文件的使用请点击：stdarg.h基本简介

数组的基本函数实现：

base.h

//base.h
//-----公用的常量和类型----------
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<stdarg.h>
//标准头文件，提供宏 va_start、 va_arg、va_end
//用于存储变长参数表
using namespace std;

//函数结果状态代码

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define UNDERFLOW -1

typedef int Status;
typedef int ElemType;

array.h

//arryay.h
//数组的基本函数实现

#define MAX_ARRAY_DIM 8
//-----数组的顺序存储表示------
typedef struct{
    ElemType *base; //数组的元素基址，由InitArray分配
    int dim;       //数组维数
    int *bounds;   //数组维界基址，由InitArray分配
    int *constants; //数组映像函数常量基址，由InitArray分配
    int elemtotal = 1;  //存放元素总个数
}Array;

//-----基本操作的函数原型说明----

//若维数dim和随后的各维长度合法，则构造相应的数组A，并返回OK
Status InitArray(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;
    va_start(ap, dim);  //ap为va_list 类型，是存放变长参数表信息的数组
    int i;
    for(i = 0; i < dim; ++i){
        A.bounds[i] = va_arg(ap, int);//从ap中取出一个整数值
        if(A.bounds[i] < 0)
            return UNDERFLOW;
        A.elemtotal *= A.bounds[i]; //元素总数
    }
    va_end(ap);
    A.base = (ElemType *)malloc(A.elemtotal * sizeof(ElemType));
    if(!A.base)
        exit(OVERFLOW);
    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;
}//InitArray

//销毁数组A
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;

    cout<<"数组销毁成功！"<<endl;
    return OK;
}//DestroyArray

//若ap知识的各下标值合法，则求出给元素在A中的相对地址
Status Locate(Array A, va_list ap, int &off){
    off = 0;
    int i;
    for(i = 0; i < A.dim; ++i){
        int ind = va_arg(ap, int);
        if(ind < 0 || ind >= A.bounds[i])
            return OVERFLOW;
        off += A.constants[i] * ind;
    }
    return OK;
}//Locate

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

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

//返回数组内元素总个数
int ArrayLength(Array A){
    return A.elemtotal;
}//ArrayLength

main.cpp

#include "base.h"
#include "array.h"

int main(){
    ElemType e;
    Array A;
    InitArray(A, 2, 2, 3);
    int i, j,k;
    for(i=0,e=1 ; i<2; i++)
        for(j=0; j<3; j++, e++)
            SetValue(A, e , i, j);
    GetValue(A, e, 1, 2);
    cout<<"A[1][2]为："<<e<<endl;
    cout<<"数组总共有："<<ArrayLength(A)<<"个元素"<<endl;
    for(i=0; i<2; i++){
        for(j=0; j<3; j++){
            GetValue(A, e , i, j);
            cout<<"A["<<i<<"]["<<j<<"]="<<e<<"  ";
        }
        cout<<endl;
    }
    return OK;
}

程序测试结果：

程序输出结果：

A[1][2]为：6
数组总共有：6个元素
A[0][0]=1  A[0][1]=2  A[0][2]=3
A[1][0]=4  A[1][1]=5  A[1][2]=6