数组

数组的定义:

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

数组的特点:

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

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

数组的基本函数实现:

base.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
//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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#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;
}

程序测试结果:

程序输出结果:

1
2
3
4
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
坚持原创技术分享,您的支持将鼓励我继续创作!